<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ESRI.ArcGIS.Client.Printing</name>
    </assembly>
    <members>
        <member name="T:ESRI.ArcGIS.Client.Printing.BaseEventArgs">
            <summary>
            Base EventArgs for the task events.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.BaseEventArgs.UserState">
            <summary>
             Gets the unique identifier for the asynchronous task.
            </summary>
            <value> An object reference that uniquely identifies the asynchronous task; otherwise,
            null if no value has been set.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.BaseEventArgs.Error">
            <summary>
            The error returned from executing the task.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintEventArgs">
            <summary>
            EventArgs for the <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteCompleted"/> event of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask"/>.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintEventArgs.#ctor(ESRI.ArcGIS.Client.Printing.PrintResult,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintEventArgs"/> class.
            </summary>
            <param name="printResult">The print result.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintEventArgs.#ctor(System.Exception,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintEventArgs"/> class.
            </summary>
            <param name="error">The error.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintEventArgs.PrintResult">
            <summary>
            Gets or sets the print result.
            </summary>
            <value>The print result.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs">
            <summary>
            EventArgs for the <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted"/> event of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask"/>.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs.#ctor(ESRI.ArcGIS.Client.Printing.PrintServiceInfo,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs"/> class.
            </summary>
            <param name="serviceInfo">The service info.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs.#ctor(System.Exception,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs"/> class.
            </summary>
            <param name="error">The error.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs.ServiceInfo">
            <summary>
            Gets or sets the service info.
            </summary>
            <value>The service info.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs">
            <summary>
            EventArgs for the <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted"/> event of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask"/>.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs.#ctor(ESRI.ArcGIS.Client.Printing.PrintResult,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs"/> class.
            </summary>
            <param name="printResult">The print result.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs.#ctor(System.Exception,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs"/> class.
            </summary>
            <param name="error">The error.</param>
            <param name="userToken">The user token.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs.PrintResult">
            <summary>
            Gets or sets the print result.
            </summary>
            <value>The print result.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs.PrintJobInfo">
            <summary>
            Gets the job info.
            </summary>
            <value>The job info.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.ExportOptions">
            <summary>
            Defines export settings for the output map.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.ExportOptions.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.ExportOptions"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ExportOptions.Dpi">
            <summary>
            Gets or sets the DPI.
            Optional. 
            Default: 96
            </summary>
            <value>The DPI.</value>		
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ExportOptions.OutputSize">
            <summary>
            Gets or sets the size of the output map in pixels.
            Required only when LayoutTemplate is empty or MAP_ONLY.		
            </summary>
            <value>The size of the output map in pixels.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.LayoutOptions">
            <summary>
            Defines settings for different available page layout elements.
            Replaces properties of existing elements in LayoutTemplate.
            </summary>
            <remarks>
            <para><b><u>Layout Templates</u></b></para>
            <para>
            One common request by ArcGIS developers is the ability to produce a printed map with various marginalia. 
            Marginalia are elements on a map that enhance its viewing and include items such as legends, titles, 
            grids and graticules, scale bars, scale text, north arrows, spatial reference information, additional 
            graphics and text items. For both asynchronous (via the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.SubmitJobAsync</see> 
            Method) and synchronous (via the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">PrintTask.ExecuteAsync</see> 
            Method) geoprocessing tasks on ArcGIS Server, it is the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutOptions">Printing.PrintParameters.LayoutOptions</see> 
            Property that controls the visual representation of the marginalia in the map that is returned from ArcGIS Server. 
            </para>
            <para>
            The LayoutOptions Class provides a mechanism to set various marginalia to augment what is seen in the Map 
            Control on a printed map. Depending on the ArcMap graphic <b>Elements</b> in the <b>Layout Template</b> 
            used to generate a printed map via the PrintTask Class, developers can set several LayoutOptions Class 
            Properties to control the marginalia. 
            </para>
            <para>
            Note: An example of producing map with various marginalia using a <b>Layout Template</b> can be found in 
            the example code section of this document.
            </para>
            <para>
            A <b>Layout Template</b> is a map document (.mxd) that is used to define the placement of a map 
            and marginalia for use by ArcGIS Server to generate an output image. The default location where 
            the <b>Layout Templates</b> are stored on ArcGIS Server is 
            <b>&lt;install_directory&gt;\Templates\ExportWebMapTemplates</b> (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Default location of Layout Template map documents on ArcGIS Server." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_1.png"/>
            </para>
            <para>
            The filename without the .mxd extension should exactly match the names of the <b>Layout Templates</b> 
            that are listed in <b>Layout_Template</b> parameter of the <b>ArcGIS REST Services Directory</b> under 
            the <b>Choice List</b> option (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Finding Layout Template options in the ArcGIS REST Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_2.png"/>
            </para>
            <para>
            The default <b>Layout Templayes</b> may not make use of every option available in the various LayoutOptions 
            Class Properties. It is the developer’s responsibility to work with the ArcGIS Server manager/administrator 
            to understand what graphic <b>Elements</b> of a specific <b>Layout Template</b> is available for 
            customization via the LayoutOptions Class Properties. The following table provides a list of the ArcMap 
            supported graphic <b>Elements</b> in the <b>Layout Template</b> and how they correspond to the 
            LayoutOptions Class Properties:
            </para>
            <list type="table">  
            <listheader>
              <term>ArcMap graphic Element in the Layout Template</term>
              <description>ESRI.ArcGIS.Client.Printing.LayoutOptions Class Properties</description>
            </listheader>  
            <item>
              <term>Title</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Title">LayoutOptions.Title</see> Property</description>
            </item>
            <item>
              <term>Text</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">LayoutOptions.CustomTextElements</see> Property</description>
            </item>
            <item>
              <term>DynamicText | Author</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.AuthorText">LayoutOptions.AuthorText</see> Property</description>
            </item>
            <item>
              <term>DynamicText | Service Layer Credits</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Copyright">LayoutOptions.Copyright</see> Property</description>
            </item>
            <item>
              <term>Legend</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.LegendOptions">LayoutOptions.LegendOptions</see> Property</description>
            </item>
            <item>
              <term>Scale Bar</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.ScaleBarOptions">LayoutOptions.ScaleBarOptions</see> Property</description>
            </item>
            </list>
            <para>
            Note: the ArcMap <b>DataFrame</b> graphic <b>Element</b> in the <b>Layout Template</b> corresponds 
            to the <see cref="T:ESRI.ArcGIS.Client.Map">Map Control</see> and is automatically set using the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutTemplate">Printing.PrintParameters.LayoutTemplate</see> Property.
            </para>
            <para>
            It should be mentioned that there are numerous other ArcMap graphic <b>Elements</b> in a 
            <b>Layout Template</b> that can be used to create an output map via the PrintTask Class. Not all of these 
            graphic <b>Elements</b> can be controlled from the client application; they are static in nature in that 
            they are preset when the <b>Layout Template</b> is originally created and published as a PrintTask 
            ExportWebMap service via ArcGIS Server. The following ArcMap screen shot shows all of the graphic 
            <b>Elements</b> that can  be used in a <b>Layout Template</b> with those that can be controlled/adjusted 
            by the client application highlighted in red:
            </para>
            <para>
            <img border="0" alt="ArcMap Elements that can be controlled from a client application for printing via the PrintTask are highlighted in red." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions_1.png"/>
            </para>
            <para>
            The default installed <b>Layout Templates</b> may be insufficient to generate maps for custom client 
            applications. Esri provides the ability to create custom <b>Layout Templates</b> with ArcMap and publish 
            them as a print service via the ExportWebMap Geoprocessing task. The ArcGIS Server manager/administrator 
            should work closely with the client application developer to achieve desired results in generating the 
            custom <b>Layout Template</b>. During this process it may be necessary to go through several iterations 
            to get the desired result. It should be noted that once a particular ExportWebMap Geoprocessing task is 
            published on ArcGIS Server, that a snapshot of the ArcMap <b>Layout Template</b> .mxd document is used 
            to generate the service. It is not possible to make a modification to the ArcMap <b>Layout Template</b> 
            .mxd document and have that change reflected in an existing ExportWebMap Geoprocessing task service. If 
            a change to the ArcMap <b>Layout Template</b> .mxd document is made, the ArcGIS Server ExportWebMap 
            Geoprocessing task service should be deleted and re-published to reflect the new changes in the 
            <b>Layout Template</b>. The 
            <see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">LayoutOptions.CustomTextElements</see> 
            Property document provides a code example with workflow of how to create a custom <b>Layout Template</b> 
            and publish an ArcGIS Server print task via the ExportWebMap Geoprocessing task service.
            </para>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            When the application loads, enter a correct Url to an ArcGIS Server PrintTask based on a 
            'synchronous geoprocessing task'. Use the default options (or specify your own) for generating an 
            output map using the parameters of: Layout Template, image Format, Copyright information, and map 
            Title. Then click the 'Make a map for printing' button to generate the output.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Printing a map using various marginalia." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions_2.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              
              &lt;!-- Add a Map Control. Zoom to the Continental United States. --&gt;
              &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="4,253,0,0" VerticalAlignment="Top"
                        Name="MyMap"  WrapAround="True" Height="300" Width="566" BorderBrush="Black" BorderThickness="1"
                        Extent="-15582663,1650611,-5474071,6991676"&gt;
                &lt;esri:Map.Layers&gt;
                  &lt;esri:LayerCollection&gt;
                
                     &lt;!-- Add an ArcGISDynamicMapServiceLayer as a backdrop. --&gt;
                     &lt;esri:ArcGISDynamicMapServiceLayer ID="World_Light_Gray_Base"
                           Url="http://services.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer"/&gt;
                
                     &lt;!-- Add a FeatureLayer that shows the United States unemplopment rate by state. --&gt;
                     &lt;esri:FeatureLayer ID="USA_Unemployment_Rate"
                           Url="http://services.arcgisonline.com/ArcGIS/rest/services/Demographics/USA_Unemployment_Rate/MapServer/4" /&gt;
                      
                  &lt;/esri:LayerCollection&gt;
                &lt;/esri:Map.Layers&gt;
              &lt;/esri:Map&gt;
              
              &lt;!-- Get the PrintTask.Url. --&gt;
              &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="562" FontSize="10" /&gt;
              
              &lt;!-- Button to perform the work. --&gt;
              &lt;Button Content="Make map for printing" Height="25" Width="229" HorizontalAlignment="Left" Margin="12,147,0,0" 
                      Name="Button_ExecuteAsync" VerticalAlignment="Top" Click="Button_ExecuteAsync_Click" /&gt;
              
              &lt;!-- Give the user options to specify different: Layout Templates, image Formats, Copyright information, 
                   and Title for the output PrintTask operation. --&gt;
              &lt;sdk:Label Height="19" Margin="12,178,0,0" Name="Label_LayoutTemplate" 
                         VerticalAlignment="Top" Content="Layout Template:" HorizontalAlignment="Left" Width="111" /&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="122,178,0,0" Name="TextBlock_LayoutTemplate" 
                         VerticalAlignment="Top" Width="448" Text="A3 Landscape"/&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="11,194,0,0" Name="Label_Format" 
                         VerticalAlignment="Top" Width="52" Content="Format:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="59,194,0,0" Name="TextBlock_Format" 
                         VerticalAlignment="Top" Width="511" Text="PDF"/&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="12,212,0,0" Name="Label_Copyright" 
                         VerticalAlignment="Top" Width="63" Content="Copyright:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="72,212,0,0" Name="TextBlock_Copyright" 
                         VerticalAlignment="Top" Width="498" Text="ACME company - all rights reserved."/&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="14,229,0,0" Name="Label_Title" 
                         VerticalAlignment="Top" Width="36" Content="Title:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="48,229,0,0" Name="TextBlock_Title" 
                         VerticalAlignment="Top" Width="522" Text="United States Unemployment Rate"/&gt;
              
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="94" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="622" 
                   TextWrapping="Wrap" Text="When the application loads, enter a correct Url to an ArcGIS Server PrintTask based 
                   on a 'synchronous geoprocessing task'. Use the default options (or specify your own) for generating an 
                   output map using the parameters of: Layout Template, image Format, Copyright information, and map 
                   Title. Then click the 'Make a map for printing' button to generate the output." /&gt;
                
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            // Create Global (aka. Member) variable for the PrintTask object that will be 
            // used in other parts of the application.
            public ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = true;
              
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              _PrintTask.ExecuteCompleted += printTask_ExecuteCompleted;
            }
            
            private void Button_ExecuteAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // The user clicked the button to generate an output map image.
              
              // Define the PrintParameters.
              ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
              
              // Set the PrintParameters.LayoutTemplate to a valid Layout_Template in the Export Web Map Task service.
              myPrintParameters.LayoutTemplate = TextBlock_LayoutTemplate.Text;
              
              // Set the PrintParameters.Format to a valid image Format in the Export Web Map Task service.
              myPrintParameters.Format = TextBlock_Format.Text;
              
              // Define the MapOptions. It is imperative that this Class be used but only the Map.Extent be provided
              // (either via the constructor or via the Property). Do not set the MapOptions.Scale Property! We want 
              // the PrintTask on ArcGIS Server to maintain the same Extent between the Map Control and the Data Frame
              // in the Layout Template, the Scale on ArcGIS server will be adjusted according to the Extent and the
              // size of the Data Frame in the Layout Template.
              ESRI.ArcGIS.Client.Printing.MapOptions myMapOptions = new ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent);
              myPrintParameters.MapOptions = myMapOptions;
              
              // Specify the LayoutOptions to provide marginalia in the output map.
              ESRI.ArcGIS.Client.Printing.LayoutOptions myLayoutOptions = new ESRI.ArcGIS.Client.Printing.LayoutOptions();
              
              // Set the Copyright text for the map.
              myLayoutOptions.Copyright = TextBlock_Copyright.Text;
              
              // Set the Title for the map.
              myLayoutOptions.Title = TextBlock_Title.Text;
              
              // ---------------------------------------------------------------------------------------------
              // Define the LegendOptions. This will show specified Layers in the printed map's legend area.
              ESRI.ArcGIS.Client.Printing.LegendOptions myLegendOptions = new ESRI.ArcGIS.Client.Printing.LegendOptions();
              
              // Define a List&lt;LegendLayer&gt; objects to put in the LegendOptions.
              List&lt;ESRI.ArcGIS.Client.Printing.LegendLayer&gt; myLegendLayers = new List&lt;ESRI.ArcGIS.Client.Printing.LegendLayer&gt;();
              
              // Loop through all of the Layers in the Map Control.
              foreach (var myLayer in MyMap.Layers)
              {
                // Create a new LegendLayer object to put in the List&lt;LegendLayer&gt; collection.
                ESRI.ArcGIS.Client.Printing.LegendLayer myLegendLayer = new ESRI.ArcGIS.Client.Printing.LegendLayer();
                
                // Set the LegendLayer.LayerId to the Layer.ID to add it to the printed map's legend area.
                myLegendLayer.LayerId = myLayer.ID;
                
                // Add a single LegendLayer into the List&lt;LegendLayer&gt; collection.
                myLegendLayers.Add(myLegendLayer);
              }
              
              // Set the LegendOptions.LegendLayer to the new constructed List&lt;LegendLayer&gt; objects.
              myLegendOptions.LegendLayers = myLegendLayers;
              
              // Set the LayoutOptions.LegendOptions to manage what the Legend looks like in the output map.
              myLayoutOptions.LegendOptions = myLegendOptions;
              //--------------------------------------------------------------------------------------------------
              
              // Define the ScaleBarOptions. This will modify the appearance of the ScaleBar in the map.
              ESRI.ArcGIS.Client.Printing.ScaleBarOptions myScaleBarOptions = new ESRI.ArcGIS.Client.Printing.ScaleBarOptions();
              
              // Define the metric and non-metric display values and their units.
              myScaleBarOptions.MetricLabel = "KILOMETERS";
              myScaleBarOptions.MetricUnit = ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnits.Kilometers;
              myScaleBarOptions.NonMetricLabel = "MILES";
              myScaleBarOptions.NonMetricUnit = ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.Miles;
              
              // Set the LayoutOptions.ScaleBarOptions tp ,anage what the Scalebar looks like in the output map.
              myLayoutOptions.ScaleBarOptions = myScaleBarOptions;
              
              // Add everything to the PrintParameters.LayoutOptions.
              myPrintParameters.LayoutOptions = myLayoutOptions;
              
              
              // NOTE: 
              // If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              // using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              // NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              // the pending request or wait for it to complete." 
              // In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              if (_PrintTask.IsBusy == true)
              {
                // There is an existing 'synchronous geoprocessing task' PrintTask running. 
                // Wait a few moments for the output to be generated and click the button again.
              }
              else if (_PrintTask.IsBusy == false)
              {
                // There is not an existing 'synchronous geoprocessing task' PrintTask running.
                
                // Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                _PrintTask.ExecuteAsync(myPrintParameters);
              }
            }
            
            private void printTask_ExecuteCompleted(object sender, ESRI.ArcGIS.Client.Printing.PrintEventArgs e)
            {
              // Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              // Get any error information (add your own enhancements if desired). 
              System.Exception mySystemException = e.Error;
              if (mySystemException != null)
              {
                MessageBox.Show(mySystemException.ToString());
              }
              
              // Get the PrintResult from the completed operation.
              ESRI.ArcGIS.Client.Printing.PrintResult myPrintResult = e.PrintResult;
              
              // Test is we have valid return PrintResults.
              if (myPrintResult != null)
              {
                // Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                List&lt;ESRI.ArcGIS.Client.Tasks.GPMessage&gt; myListOfGPMessage = myPrintResult.Messages;
                
                // Get the location of the image/.pdf created by ArcGIS Server.
                System.Uri myUri = myPrintResult.Url;
                
                // Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank");
              }
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create Global (aka. Member) variable for the PrintTask object that will be 
            ' used in other parts of the application.
            Public _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
            
            Public Sub New()
            
              InitializeComponent()
              
              ' Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = True
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              AddHandler _PrintTask.ExecuteCompleted, AddressOf printTask_ExecuteCompleted
              
            End Sub
            
            Private Sub Button_ExecuteAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' The user clicked the button to generate an output map image.
              
              ' Define the PrintParameters.
              Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
              
              ' Set the PrintParameters.LayoutTemplate to a valid Layout_Template in the Export Web Map Task service.
              myPrintParameters.LayoutTemplate = TextBlock_LayoutTemplate.Text
              
              ' Set the PrintParameters.Format to a valid image Format in the Export Web Map Task service.
              myPrintParameters.Format = TextBlock_Format.Text
              
              ' Define the MapOptions. It is imperative that this Class be used but only the Map.Extent be provided
              ' (either via the constructor or via the Property). Do not set the MapOptions.Scale Property! We want 
              ' the PrintTask on ArcGIS Server to maintain the same Extent between the Map Control and the Data Frame
              ' in the Layout Template, the Scale on ArcGIS server will be adjusted according to the Extent and the
              ' size of the Data Frame in the Layout Template.
              Dim myMapOptions As New ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent)
              myPrintParameters.MapOptions = myMapOptions
              
              ' Specify the LayoutOptions to provide marginalia in the output map.
              Dim myLayoutOptions As New ESRI.ArcGIS.Client.Printing.LayoutOptions
              
              ' Set the Copyright text for the map.
              myLayoutOptions.Copyright = TextBlock_Copyright.Text
              
              ' Set the Title for the map.
              myLayoutOptions.Title = TextBlock_Title.Text
              
              ' ---------------------------------------------------------------------------------------------
              ' Define the LegendOptions. This will show specified Layers in the printed map's legend area.
              Dim myLegendOptions As New ESRI.ArcGIS.Client.Printing.LegendOptions
              
              ' Define a List(Of LegendLayer) objects to put in the LegendOptions.
              Dim myLegendLayers As New List(Of ESRI.ArcGIS.Client.Printing.LegendLayer)
              
              ' Loop through all of the Layers in the Map Control.
              For Each myLayer In MyMap.Layers
                
                ' Create a new LegendLayer object to put in the List(Of LegendLayer) collection.
                Dim myLegendLayer As New ESRI.ArcGIS.Client.Printing.LegendLayer
                
                ' Set the LegendLayer.LayerId to the Layer.ID to add it to the printed map's legend area.
                myLegendLayer.LayerId = myLayer.ID
                
                ' Add a single LegendLayer into the List(Of LegendLayer) collection.
                myLegendLayers.Add(myLegendLayer)
                
              Next
              
              ' Set the LegendOptions.LegendLayer to the new constructed List(Of LegendLayer) objects.
              myLegendOptions.LegendLayers = myLegendLayers
              
              ' Set the LayoutOptions.LegendOptions to manage what the Legend looks like in the output map.
              myLayoutOptions.LegendOptions = myLegendOptions
              '--------------------------------------------------------------------------------------------------
              
              ' Define the ScaleBarOptions. This will modify the appearance of the ScaleBar in the map.
              Dim myScaleBarOptions As New ESRI.ArcGIS.Client.Printing.ScaleBarOptions
              
              ' Define the metric and non-metric display values and their units.
              myScaleBarOptions.MetricLabel = "KILOMETERS"
              myScaleBarOptions.MetricUnit = ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnits.Kilometers
              myScaleBarOptions.NonMetricLabel = "MILES"
              myScaleBarOptions.NonMetricUnit = ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.Miles
              
              ' Set the LayoutOptions.ScaleBarOptions tp ,anage what the Scalebar looks like in the output map.
              myLayoutOptions.ScaleBarOptions = myScaleBarOptions
              
              ' Add everything to the PrintParameters.LayoutOptions.
              myPrintParameters.LayoutOptions = myLayoutOptions
              
              
              ' NOTE: 
              ' If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              ' using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              ' NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              ' the pending request or wait for it to complete." 
              ' In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              If _PrintTask.IsBusy = True Then
                
               ' There is an existing 'synchronous geoprocessing task' PrintTask running. 
               ' Wait a few moments for the output to be generated and click the button again.
                
              ElseIf _PrintTask.IsBusy = False Then
                
                 ' There is not an existing 'synchronous geoprocessing task' PrintTask running.
                 
                 ' Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                 _PrintTask.ExecuteAsync(myPrintParameters)
                
              End If
              
            End Sub
            
            Private Sub printTask_ExecuteCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.PrintEventArgs)
              
              ' Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              ' Get any error information (add your own enhancements if desired). 
              Dim mySystemException As System.Exception = e.Error
              If mySystemException IsNot Nothing Then
                MessageBox.Show(mySystemException.ToString)
              End If
              
              ' Get the PrintResult from the completed operation.
              Dim myPrintResult As ESRI.ArcGIS.Client.Printing.PrintResult = e.PrintResult
              
              ' Test is we have valid return PrintResults.
              If myPrintResult IsNot Nothing Then
                
                ' Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                Dim myListOfGPMessage As List(Of ESRI.ArcGIS.Client.Tasks.GPMessage) = myPrintResult.Messages
                
                ' Get the location of the image/.pdf created by ArcGIS Server.
                Dim myUri As System.Uri = myPrintResult.Url
                 
                ' Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank")
                
              End If
              
            End Sub
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.LayoutOptions.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.LayoutOptions"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Title">
            <summary>
            Gets or sets the map title.
            </summary>
            <value>The map title.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Copyright">
            <summary>
            Gets or sets the copyright text.
            </summary>
            <value>The copyright text.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.ScaleBarOptions">
            <summary>
            Gets or sets the scale bar options.
            </summary>
            <value>The scale bar options.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.AuthorText">
            <summary>
            Gets or sets the author text.
            </summary>
            <value>The author text.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.LegendOptions">
            <summary>
            Gets or sets the legend options.
            </summary>
            <value>The legend options.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">
            <summary>
            Gets or sets the custom text elements.
            Optional but recommended when updating text of a TextElement 
            (not DynamicText) on the page layout. 
            </summary>
            <value>The custom text elements.</value>
            <remarks>
            <para>
            In order to programmatically change a generic Text Element in the marginalia of a map from the 
            client, first a custom <b>Layout Template</b> must be created using ArcMap. The author of the 
            <b>Layout Template</b> .mxd file must share with the developer the <b>Element Name</b> of the 
            inserted Text Element so that this can be used in constructing the Dictionary that is passed 
            to the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">Printing.LayoutOptions.CustomTextElements</see> 
            Property. The following is a screen shot of the Properties dialog for a Text Element that was 
            added to the <b>Layout View</b> design surface of a <b>Layout Template</b> .mxd file (note that 
            the <b>Element Name</b> is "MyCustomTextElement"):
            </para>
            <para>
            <img border="0" alt="A custom Text Element Properties dialog. Make sure and specify a value for the 'Element Name'." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_2.png"/>
            </para>
            <para>
            And the corresponding code snippet to programmatically change the Text Element when using the PrintTask:
            </para>
            <para><u>C#</u></para>
            <code>
            ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
            ...
            ESRI.ArcGIS.Client.Printing.LayoutOptions myLayoutOptions = new ESRI.ArcGIS.Client.Printing.LayoutOptions();
            Dictionary&lt;string, string&gt; myCustomElements = new Dictionary&lt;string, string&gt;();
            
            // The "MyCustomTextElement" is the Element Name in the Layout Template .mxd file.
            myCustomElements.Add("MyCustomTextElement", "LOOK I CAN CHANGE THIS STRING");
            myLayoutOptions.CustomTextElements = myCustomElements;
            ...
            myPrintParameters.LayoutOptions = myLayoutOptions;
            </code>
            <para><u>VB.NET</u></para>
            <code>
            Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
            ...
            Dim myLayoutOptions As New ESRI.ArcGIS.Client.Printing.LayoutOptions
            Dim myCustomElements As New Dictionary(Of String, String)
            
            ' The "MyCustomTextElement" is the Element Name in the Layout Template .mxd file.
            myCustomElements.Add("MyCustomTextElement", "LOOK I CAN CHANGE THIS STRING")
            myLayoutOptions.CustomTextElements = myCustomElements
            ...
            myPrintParameters.LayoutOptions = myLayoutOptions
            </code>
            </remarks>
            <example>
            <para>
            The following steps show one example workflow of how a developer could create a custom <b>Layout Template</b> 
            in which a Text Element (that can be modified by the LayoutOptions.CustomTextElements  
            Property) and some other graphic Elements are added. For this workflow it is assumed that ArcMap, ArcGIS 
            Server, and Visual Studio are installed on the same machine. The machine name used in this example is 
            called <b>DK-RED2A</b> but you will need to substitute you own machine name to follow along. 
            </para>
            <para><u>Step 1: Author the <b>Layout Template</b> in ArcMap</u></para>
            <list type="bullet">
             <item>
             <para>
             Start ArcMap.
             </para>
             </item>
             <item>
             <para>
             Switch to the <b>Layout View</b> (a <b>Data Frame</b> Element will already be provided on 
             the design surface).
             </para>
             </item>
             <item>
             <para>
             Add the following graphic <b>Elements</b> onto the design surface and ensure they have the 
             following specific Properties being set:
             </para>
              <list type="bullet">
               <item>
               <para>
               <b>Text</b> (Ensure the <b>Element Name</b> is "MyCustomTextElement".) 
               </para>
               <para>
                <img border="0" alt="The MyCustomTextElement Properties dialog. Make sure and specify a value for the 'Element Name'." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_2.png"/>
               </para>
               </item>
               <item>
               <para>
               <b>North Arrow</b> (No specific property changes are necessary.)
               </para>
               </item>
               <item>
               <para>
               <b>Picture</b> (Ensure the check box is checked on for the <b>Save Image as Part of Document</b>. 
               Use any test image you have available for the <b>Source</b>.)
               </para>
               <para>
                <img border="0" alt="The Picture Properties dialog. Make sure the 'Save Image as Part of Document' is checked." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_3.png"/>
               </para>
               </item>
               </list>
             </item>
             <item>
             <para>
             Save the ArcMap <b>Layout Template</b> document as <b>C:\MyCustomTemplates\MyCustomTemplate1.mxd</b>:
             </para>
             <para>
               <img border="0" alt="Save the custom 'Layout Template' as C:\MyCustomTemplates\MyCustomTemplate1.mxd." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_5.png"/>
             </para>
             </item>
             <item>
             <para>
             Resize and move the graphic Elements around until it looks similar to the following screen shot and 
             then re-save the project:
             </para>
             <para>
               <img border="0" alt="Example of the completed layout of the saved 'Layout Template' .mxd file." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_6.png"/>
             </para>
             </item>
            </list>
            <para><u>Step2: Publish the <b>Layout Template</b> on ArcGIS Server</u></para>
            <list type="bullet">
             <item>
             <para>
             In ArcMap, open ArcToolbox, expand the <b>Server Tools</b> | <b>Printing</b> nodes and double 
             click on the <b>Export Web Map</b> tool: 
             </para>
             <para>
              <img border="0" alt="Find the ArcToolbox | Server Tools | Printing | Export Web Map geoprocessing tool in ArcMap." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_7.png"/>
             </para>
             </item>
             <item>
             <para>
             In the <b>Export Web Map</b> dialog that opens: (1) delete what is currently set for the image 
             Format (this will enable any valid image type to be specified via the 
             <see cref="P:ESRI.ArcGIS.Client.Printing.PrintParameters.Format">Printing.PrintParameters.Format</see> 
             Property); (2) click the folder icon in the <b>Layout Template Folder</b> section and set it to 
             the location of where the custom <b>Layout Template</b> .mxd was stored (<b>C:\MyCustomTemplates</b> 
             in this example); (3) Then click <b>OK</b>. This will begin the process of creating the 
             <b>Export Web Map</b> service:
             </para>
             <para>
              <img border="0" alt="Specifying the correct parameters ofthe Export Web Map dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_8.png"/>
             </para>
             </item>
             <item>
             <para>
             When the <b>Export Web Map</b> Geoprocessing task is done, open the <b>Results</b> tab, and expand 
             the <b>Current Session</b> | <b>ExportWebMap</b> nodes. Then right click on the <b>ExportWebMap</b> 
             node and choose <b>Share As</b> | <b>GeoProcessing Service</b> from the context menus:
             </para>
             <para>
              <img border="0" alt="Use ArcMap to share a Geoprocessing Service for the custom ExportWebMap task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_9.png"/>
             </para>
             </item>
             <item>
             <para>
             This will open the <b>Share as Service</b> dialog to publish the ExportWebMap Task on ArcGIS Server. 
             Make sure the <b>Publish a service</b> radio button is checked and click the <b>Next</b> buton:
             </para>
             <para>
              <img border="0" alt="Choose the default options in the Share as Service dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_10.png"/>
             </para>
             </item>
             <item>
             <para>
             In the <b>Insecure Token Service URL</b> dialog choose <b>Yes</b> (this example does not use secure token 
             services):
             </para>
             <para>
              <img border="0" alt="Choose Yes in the Insecure Token Service URL dialog to publich a service without security tokens." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_11.png"/>
             </para>
             </item>
             <item>
             <para>
             If the <b>GIS Server Connection</b> dialog appears specify the correct <b>User Name</b> and <b>Password</b> 
             for the ArcGIS Server:
             </para>
             <para>
              <img border="0" alt="Specify the correct User Name and Password credentials in the GIS Server Connection dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_14.png"/>
             </para>
             </item>
             <item>
             <para>
             When the <b>Publish a Service</b> dialog opens, choose the correct Connection for ArcGIS Server and specify 
             the Service name as "MyCustomPrintTask" (we will discover the Url for this ExportWebMap PrintTask later):
             </para>
             <para>
              <img border="0" alt="Specify the service name 'MyCustomPrintTask' in the Publish a Service dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_11F.png"/>
             </para>
             </item>
             <item>
             <para>
             Accept the default values of <b>Use existing folder</b> and click the <b>Continue</b> button:
             </para>
             <para>
              <img border="0" alt="Accept the default values on the Publish a Servie dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_12.png"/>
             </para>
             </item>
             <item>
             <para>
             In the <b>Service Editor</b> dialog, accept the default options and click the <b>Publish</b> button in the 
             upper right corner (Note: by default this will create an asynchronous Execution Mode service):
             </para>
             <para>
              <img border="0" alt="Accept the default publishing options on the Service Editor dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_13.png"/>
             </para>
             </item>
             <item>
             <para>
             If the <b>GIS Server Connection</b> dialog appears specify the correct <b>User Name</b> and <b>Password</b> 
             for the ArcGIS Server:
             </para>
             <para>
              <img border="0" alt="Specify the correct User Name and Password credentials in the GIS Server Connection dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_14.png"/>
             </para>
             </item>
             <item>
             <para>
             At this point the service should be created successfully. You can obtain the <b>REST URL</b> of the 
             ExportWebMap PrintTask service from the ArcGIS Server Manager:
             </para>
             <para>
              <img border="0" alt="Verifying that the ExportWebMap service was created successfully in the ArcGIS Server Manager." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_15.png"/>
             </para>
             </item>
             <item>
             <para>
             </para>
             Using the <b>REST URL</b> string from the prior screen shot, copy it into the address bar of your internet 
             browser. The developer should be able to access the public site for the ExportWebMap task via the 
             <b>ArcGIS REST Service Directory</b>. You should be able to see that the <b>Layout_Template</b> parameter 
             uses the custom <b>Layout Template</b> .mxd file named "MyCustomTemplate1":
             <para>
              <img border="0" alt="Ensuring that the ExportWebMap PrintTask service is availble in the ArcGIS REST Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_16.png"/>
             </para>
             </item>
            </list>
            <para><u>
            Step 3: Create a Visual Studio test project and write the code to generate a map based upon the 
            custom <b>Layout Template</b>
            </u></para>
            <list type="bullet">
             <item>
             <para>
             Launch Visual Studio 2010.
             </para>
             </item>
             <item>
             <para>
             Choose <b>File</b> | <b>New</b> Project from the Visual Studio menus.
             </para>
             </item>
             <item>
             <para>
             In the <b>New Project</b> dialog, expand .NET Language of your choice (Visual Basic shown in this 
             example), click on the <b>Silverlight Template</b>, choose <b>Silverlight Application</b>, and specify 
             the following information in the textboxes: 
             </para>
             <list type="bullet">
              <item>
              <para>
              Name: <b>SilverlightApplication1</b>
              </para>
              </item>
              <item>
              <para>
              Location: <b>C:\CustomLayoutTemplateVSProjects\</b> 
              </para>
              </item>
              <item>
              <para>
              Solution name: <b>SilverlightApplication1</b>
              </para>
              <para>
              The Visual Studio project should look similar to the followwing:
              </para>
              <para>
               <img border="0" alt="Setting up a new Silverlight project in Visual Studio." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_17.png"/>
              </para>
              </item>
             </list>
             </item>
             <item>
             <para>
             In the <b>New Silverlight Application</b> dialog, accept the defaults (make sure the <b>Host the 
             Silverlight application in a new Web site</b> is checked). This will use the Visual Studio built-in 
             web server (Cassini) for launching your Silverlight application 
             </para>
             <para>
              <img border="0" alt="Accept the defaults in the New Silverlight Application dialog." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_18.png"/>
             </para>
             </item>
             <item>
             <para>
             Drag an ESRI Silverlight API <b>Map Control</b> onto the <b>MainPage.xaml</b> design surface:
             </para>
             </item>
             <item>
             <para>
             Add the following additional <b>References</b> to the Visual Studio Project: 
             <b>ESRI.ArcGIS.Client.Printing</b> and <b>System.Windows.Controls.Data.Input</b>. 
             </para>
             </item>
             <item>
             <para>
             Replace the XAML code in the <b>MainPage.xaml</b> with the following: 
             </para>
             <code>
               &lt;UserControl x:Class="SilverlightApplication1.MainPage"
                   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                   mc:Ignorable="d"
                   d:DesignHeight="650" d:DesignWidth="650" 
                   xmlns:esri="http://schemas.esri.com/arcgis/client/2009"
                   xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk"&gt;
               
                &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
               
                 &lt;!-- Add a Map Control. Zoom to the Continental United States. --&gt;
                 &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="47,256,0,0" VerticalAlignment="Top"
                           Name="MyMap"  WrapAround="True" Height="300" Width="566" BorderBrush="Black" BorderThickness="1"
                           Extent="-15582663,1650611,-5474071,6991676"&gt;
                  &lt;esri:Map.Layers&gt;
                   &lt;esri:LayerCollection&gt;
               
                    &lt;!-- Add an ArcGISDynamicMapServiceLayer as a backdrop. --&gt;
                    &lt;esri:ArcGISDynamicMapServiceLayer ID="World_Light_Gray_Base"
                          Url="http://services.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer"/&gt;
               
                   &lt;/esri:LayerCollection&gt;
                  &lt;/esri:Map.Layers&gt;
                 &lt;/esri:Map&gt;
               
                 &lt;!-- Get the PrintTask.Url. --&gt;
                 &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                              VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
                 &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                            VerticalAlignment="Top" Width="562" FontSize="10" /&gt;
               
                 &lt;!-- Add a button to perform the work. --&gt;
                 &lt;Button Content="Make a map using my custom Layout Template" Height="23" HorizontalAlignment="Left" 
                         Margin="14,147,0,0" Name="Button1" VerticalAlignment="Top" Width="282" Click="Button1_Click"/&gt;
               
                 &lt;!-- Give the user options to specify different: Layout Templates, image Formats, and CustomTextElement 
                      information for the output PrintTask operation. --&gt;
                 &lt;sdk:Label Height="19" Margin="12,178,0,0" Name="Label_LayoutTemplate" 
                              VerticalAlignment="Top" Content="Layout Template:" HorizontalAlignment="Left" Width="111" /&gt;
                 &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="122,178,0,0" Name="TextBlock_LayoutTemplate" 
                              VerticalAlignment="Top" Width="163" Text="MyCustomTemplate1"/&gt;
                 &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="11,194,0,0" Name="Label_Format" 
                              VerticalAlignment="Top" Width="52" Content="Format:"/&gt;
                 &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="59,194,0,0" Name="TextBlock_Format" 
                              VerticalAlignment="Top" Width="226" Text="PDF"/&gt;
                 &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="12,212,0,0" Name="Label_CustomTextElement" 
                              VerticalAlignment="Top" Width="120" Content="CustomTextElement:"/&gt;
                 &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="138,212,0,0" Name="TextBlock_CustomTextElement" 
                              VerticalAlignment="Top" Width="147" Text="Dude wheres my car!"/&gt;
               
                 &lt;!-- Display the current JobInfo to the user about the status of the asynchronous PrintTask. --&gt;
                 &lt;sdk:Label Height="16" HorizontalAlignment="Left" Margin="315,147,0,0" Name="Label_JobId" VerticalAlignment="Top" 
                            Width="35" Content="JobId:"/&gt;
                 &lt;TextBlock Height="16" HorizontalAlignment="Left" Margin="356,147,0,0" Name="TextBlock_JobId" 
                            VerticalAlignment="Top" Width="256" /&gt;
                 &lt;sdk:Label Height="15" Margin="291,169,0,0" Name="Label_JobStatus" VerticalAlignment="Top" Content="JobStatus:" 
                            HorizontalAlignment="Left" Width="65" /&gt;
                 &lt;TextBlock Height="15" Margin="356,169,187,0" Name="TextBlock_JobStatus" VerticalAlignment="Top" /&gt;
                 &lt;sdk:Label Height="23" HorizontalAlignment="Left" Margin="291,186,0,0" Name="Label_Messages" VerticalAlignment="Top" 
                            Width="65" Content="Messages:"/&gt;
                 &lt;ListBox Height="64" HorizontalAlignment="Left" Margin="356,186,0,0" Name="ListBox_Messages" VerticalAlignment="Top" 
                          Width="256" /&gt;
               
                 &lt;!-- Provide the instructions on how to use the sample code. --&gt;
                 &lt;TextBlock Height="94" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="480" 
                      TextWrapping="Wrap" Text=
                      "When the application loads, enter a correct Url to an ArcGIS Server PrintTask based 
                      on an 'asynchronous geoprocessing task'. Use the default options (or specify 
                      your own) for generating an output map using the parameters of: Layout 
                      Template, image Format, and CustomTextElement. Then click the 
                      'Make a map using my custom Layout Template' button to generate the output." /&gt;
               
                &lt;/Grid&gt;
               &lt;/UserControl&gt;
             </code>
             </item>
             <item>
             <para>
             Replace the <b>MainPage.xaml.vb</b> or <b>MainPage.xaml.cs</b> with the following:
             </para>
             <para><u>C#:</u></para>
             <code>
               public partial class MainPage : UserControl
               {
                // Create Global (aka. Member) variable for the PrintTask object that will be 
                // used in other parts of the application.
                public ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
             
                public MainPage()
                {
                 InitializeComponent();
             
                 // Provide a valid PrintTask.Url for a "asynchronous geoprocessing task"
                 TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/MyCustomPrintTask/GPServer/Export%20Web%20Map";
             
                 // Set the _PrintTask variable to a new instance of the PrintTask Class.
                 _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
             
                 // Prevent the internet browser from using a cache for the PrintTask operations.
                 _PrintTask.DisableClientCaching = true;
             
                 // Set the PrintTask.Url from what is entered in the TextBox.
                 _PrintTask.Url = TextBox_Url.Text;
             
                 // Wire up an Event Handler for the PrintTask.StatusUpdated Event.
                 _PrintTask.StatusUpdated += printTask_StatusUpdated;
             
                 // Wire up an Event Handler for the PrintTask.SubmitJobCompleted Event.
                 _PrintTask.JobCompleted += printTask_JobCompleted;
                }
             
                private void Button1_Click(object sender, System.Windows.RoutedEventArgs e)
                {
                 // The user clicked the button to generate an output map image.
             
                 // Define the PrintParameters.
                 ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
             
                 // Set the PrintParameters.LayoutTemplate to a valid Layout_Template in the Export Web Map Task service.
                 myPrintParameters.LayoutTemplate = TextBlock_LayoutTemplate.Text;
             
                 // Set the PrintParameters.Format to a valid image Format in the Export Web Map Task service.
                 myPrintParameters.Format = TextBlock_Format.Text;
             
                 // Define the MapOptions.
                 ESRI.ArcGIS.Client.Printing.MapOptions myMapOptions = new ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent);
                 myPrintParameters.MapOptions = myMapOptions;
             
                 // Specify the LayoutOptions to provide marginalia in the output map.
                 ESRI.ArcGIS.Client.Printing.LayoutOptions myLayoutOptions = new ESRI.ArcGIS.Client.Printing.LayoutOptions();
             
                 // Create a Dictionary to hold strings to override the displayof custom Text Elements in the Layout Template .mxd. 
                 Dictionary&lt;string, string&gt; myCustomElements = new Dictionary&lt;string, string&gt;();
             
                 // The "MyCustomTextElement" name matches the Text Element 'Element Name' in the sample Layout Template.
                 // Set the text to be what the user entered in the TextBlock of the application.
                 myCustomElements.Add("MyCustomTextElement", TextBlock_CustomTextElement.Text);
                 myLayoutOptions.CustomTextElements = myCustomElements;
             
                 // Add everything to the PrintParameters.LayoutOptions.
                 myPrintParameters.LayoutOptions = myLayoutOptions;
             
                 // Submit the asynchronous geoprocessing task to ArcGIS Server. 
                 _PrintTask.SubmitJobAsync(myPrintParameters);
                }
             
                private void printTask_JobCompleted(object sender, ESRI.ArcGIS.Client.Printing.PrintJobEventArgs e)
                {
                 // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
             
                 // Test if we have valid results coming back from ArcGIS Server.
                 if (e.PrintResult != null)
                 {
                  if (e.PrintResult.Url != null)
                  {
                   // Open a new internet browser window with the generated image from the PrintTask. 
                   System.Windows.Browser.HtmlPage.Window.Navigate(e.PrintResult.Url, "_blank");
             
                   // Clear out the JobInfo messages since we have completed the asynchronous geoprocessing task. 
                   TextBlock_JobId.Text = "";
                   TextBlock_JobStatus.Text = "";
                   ListBox_Messages.Items.Clear();
                  }
                 }
                }
             
                private void printTask_StatusUpdated(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
                {
                 // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
             
                 // This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
                 // can fire multiple times depending on the state of the geoprocessing task executing.
             
                 // Clear out any existing JobInfo messages.
                 TextBlock_JobId.Text = "";
                 TextBlock_JobStatus.Text = "";
                 ListBox_Messages.Items.Clear();
             
                 // Get the JobInfo information messages.
                 ESRI.ArcGIS.Client.Tasks.JobInfo myJobInfo = e.JobInfo;
                 string myJobId = myJobInfo.JobId;
                 ESRI.ArcGIS.Client.Tasks.esriJobStatus myJobStatus = myJobInfo.JobStatus;
                 List&lt;ESRI.ArcGIS.Client.Tasks.GPMessage&gt; myMessages = myJobInfo.Messages;
             
                 // Display the JobInfo messages to the user.
                 TextBlock_JobId.Text = myJobId;
                 TextBlock_JobStatus.Text = myJobStatus.ToString();
                 foreach (ESRI.ArcGIS.Client.Tasks.GPMessage myMessage in myMessages)
                 {
                  ListBox_Messages.Items.Add(myMessage.Description);
                 }
                }
               }
             </code>
             <para><u>VB.NET:</u></para>
             <code>
               Partial Public Class MainPage
                   Inherits UserControl
               
                ' Create Global (aka. Member) variable for the PrintTask object that will be 
                ' used in other parts of the application.
                Public _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
               
                Public Sub New()
               
                 InitializeComponent()
               
                 ' Provide a valid PrintTask.Url for a "asynchronous geoprocessing task"
                 TextBox_Url.Text = "http://dk-red2a:6080/arcgis/rest/services/MyCustomPrintTask/GPServer/Export%20Web%20Map"
               
                 ' Set the _PrintTask variable to a new instance of the PrintTask Class.
                 _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
               
                 ' Prevent the internet browser from using a cache for the PrintTask operations.
                 _PrintTask.DisableClientCaching = True
               
                 ' Set the PrintTask.Url from what is entered in the TextBox.
                 _PrintTask.Url = TextBox_Url.Text
               
                 ' Wire up an Event Handler for the PrintTask.StatusUpdated Event.
                 AddHandler _PrintTask.StatusUpdated, AddressOf printTask_StatusUpdated
               
                 ' Wire up an Event Handler for the PrintTask.SubmitJobCompleted Event.
                 AddHandler _PrintTask.JobCompleted, AddressOf printTask_JobCompleted
               
                End Sub
               
                Private Sub Button1_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
               
                 ' The user clicked the button to generate an output map image.
               
                 ' Define the PrintParameters.
                 Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
               
                 ' Set the PrintParameters.LayoutTemplate to a valid Layout_Template in the Export Web Map Task service.
                 myPrintParameters.LayoutTemplate = TextBlock_LayoutTemplate.Text
               
                 ' Set the PrintParameters.Format to a valid image Format in the Export Web Map Task service.
                 myPrintParameters.Format = TextBlock_Format.Text
               
                 ' Define the MapOptions.
                 Dim myMapOptions As New ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent)
                 myPrintParameters.MapOptions = myMapOptions
               
                 ' Specify the LayoutOptions to provide marginalia in the output map.
                 Dim myLayoutOptions As New ESRI.ArcGIS.Client.Printing.LayoutOptions
               
                 ' Create a Dictionary to hold strings to override the displayof custom Text Elements in the Layout Template .mxd. 
                 Dim myCustomElements As New Dictionary(Of String, String)
               
                 ' The "MyCustomTextElement" name matches the Text Element 'Element Name' in the sample Layout Template.
                 ' Set the text to be what the user entered in the TextBlock of the application.
                 myCustomElements.Add("MyCustomTextElement", TextBlock_CustomTextElement.Text)
                 myLayoutOptions.CustomTextElements = myCustomElements
               
                 ' Add everything to the PrintParameters.LayoutOptions.
                 myPrintParameters.LayoutOptions = myLayoutOptions
               
                 ' Submit the asynchronous geoprocessing task to ArcGIS Server. 
                 _PrintTask.SubmitJobAsync(myPrintParameters)
               
                End Sub
               
                Private Sub printTask_JobCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.PrintJobEventArgs)
               
                 ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
               
                 ' Test if we have valid results coming back from ArcGIS Server.
                 If e.PrintResult IsNot Nothing Then
                  If e.PrintResult.Url IsNot Nothing Then
               
                   ' Open a new internet browser window with the generated image from the PrintTask. 
                   System.Windows.Browser.HtmlPage.Window.Navigate(e.PrintResult.Url, "_blank")
               
                   ' Clear out the JobInfo messages since we have completed the asynchronous geoprocessing task. 
                   TextBlock_JobId.Text = ""
                   TextBlock_JobStatus.Text = ""
                   ListBox_Messages.Items.Clear()
               
                  End If
                 End If
               
                End Sub
               
                Private Sub printTask_StatusUpdated(sender As Object, e As ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs)
               
                 ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
               
                 ' This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
                 ' can fire multiple times depending on the state of the geoprocessing task executing.
               
                 ' Clear out any existing JobInfo messages.
                 TextBlock_JobId.Text = ""
                 TextBlock_JobStatus.Text = ""
                 ListBox_Messages.Items.Clear()
               
                 ' Get the JobInfo information messages.
                 Dim myJobInfo As ESRI.ArcGIS.Client.Tasks.JobInfo = e.JobInfo
                 Dim myJobId As String = myJobInfo.JobId
                 Dim myJobStatus As ESRI.ArcGIS.Client.Tasks.esriJobStatus = myJobInfo.JobStatus
                 Dim myMessages As List(Of ESRI.ArcGIS.Client.Tasks.GPMessage) = myJobInfo.Messages
               
                 ' Display the JobInfo messages to the user.
                 TextBlock_JobId.Text = myJobId
                 TextBlock_JobStatus.Text = myJobStatus.ToString
                 For Each myMessage As ESRI.ArcGIS.Client.Tasks.GPMessage In myMessages
                  ListBox_Messages.Items.Add(myMessage.Description)
                 Next
               
                End Sub
               
               End Class
             </code>
             </item>
             <item>
             <para>
             Choose <b>Build</b> | <b>Build Solution</b> from the Visual Studio menus (you should not have any 
             compiler Errors/Warnings.
             </para>
             </item>
             <item>
             <para>
             Hit the <b>F5</b> key (or click the <b>Start Debugging</b> button) in Visual Studio to launch the 
             Silverlight application in Internet Explorer. Then click the 'Make a map using my custom Layout Template' 
             button to launch the PrintTask operation:
             </para>
             <para>
              <img border="0" alt="Click the 'Make a map using my custom Layout Template' button in the custom Silverlight application." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_19.png"/>
             </para>
             </item>
             <item>
             <para>
             The final output should appear something similar to the following screen shot:
             </para>
             <para>
              <img border="0" alt="The result of the PrintTask for the custom Layout Template where the CustomTextElements Property was used." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions.CustomTextElements_20.png"/>
             </para>
             </item>
            </list>
            </example>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.LegendOptions">
            <summary>
            Defines settings specific to Legend control
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.LegendOptions.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.LegendOptions"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LegendOptions.LegendLayers">
            <summary>
            Gets or sets the layers whose legends will be added to the layout.
            If null, all visible layers will be present in the legend.
            To specify that no layers will be included in the legend, 
            set LegendLayers to an empty array.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.LegendLayer">
            <summary>
            The LegendLayer class defines a layer that will be added to the legend in the layout.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LegendLayer.LayerId">
            <summary>
            Gets or sets the id of layer whose legend will be added to the layout.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.LegendLayer.SubLayerIds">
            <summary>
            Gets or sets the optional id's of the sub-layers whose legends will be added to the layout.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.MapOptions">
            <summary>
            Defines map display properties.
            </summary>
            <remarks>
            <para><b><u>WYSIWYG Printing of Maps</u></b></para>
            <para>
            The acronym WYSIWYG stands for "What You See Is What You Get" and is typically used to describe what 
            you view on a digital screen (i.e. desktop computer, laptop, tablet, phone, hand held device, etc.) 
            matches a hard copy print output. 
            For a typical application using a 'screen capture' type of WYSIWYG printing, the Microsoft API <a href="http://msdn.microsoft.com/en-us/library/ee671023(v=vs.95).aspx" target="_blank">Printing</a> document serves as a starting point.
            
            </para>
            <para>
            For ArcGIS developers who want to produce applications for cartographic map printing, the API's 
            provided by Microsoft may be insufficient. ESRI provides additional resources via the 
            <see cref="N:ESRI.ArcGIS.Client.Printing">ESRI.ArcGIS.Client.Printing</see> Assembly that suit 
            many of the needs for cartographic map printing via ArcGIS Server.
            </para>
            <para>
            One common request by ArcGIS developers is the ability to replicate what is seen in the Map Control 
            of an application on a printed map. In a nutshell, the key to producing a WYSIWYG printed output 
            specifically for the Map Control involves 
            </para>
            <list type="bullet">
            <item>
            <b>Knowing the Data Frame</b> - Knowing the key pieces of information on the ArcGIS Server machine 
            (specifically the <b>Data Frame</b> Height and <b>Data Frame</b> Width of the ArcMap 
            <b>Layout Template</b>).
            </item>
            <item>
            <b>Using a Ratio</b> - Ensuring that the ratio between the Height and Width of the <b>Data Frame</b> 
            in the ArcMap <b>Layout Template</b> exactly matches the ratio between the Height and Width of the 
            Map Control in the application.
            </item>
            <item>
            <b>Ensuring No Scale Dependency Layers</b> - Ensuring that any map Layers in the ArcGIS Service does 
            not use scale dependency visibility rendering (aka. no specific <b>Scale Range</b> was set in ArcMap 
            when authoring the service. Make sure that the Layer is visible for all scale levels). 
            </item>
            </list>
            <para>
            Note: An example of producing a WYSIWYG printed output specifically for the Map Control using various 
            <b>Layout Template</b> options can be found in the example code section of this document.
            </para>
            <para>
            ArcGIS Server uses the information provided from the client application to generate the image that 
            is used for printing. There are several options available in the PrintTask.PrintParameters Class 
            which can be used in almost unlimited combinations. The key to making a successful WYSIWYG printed 
            output the Map Control, first involves understanding the constraints that ArcGIS Server has to 
            generate the map image for printing. When a specific Scale and Extent are passed to ArcGIS Server 
            from the client, the image generation process attempts to center the map based upon the Extent and 
            maintain the Scale subject to the <b>Data Frame</b> that is used for a specific 
            <b>Layout Template</b>. In most cases, the size and/or aspect ratio of the of the Map Control on 
            the client does not exactly match the <b>Data Frame</b> on the ArcGIS Server and the result is often 
            seeing more or less geographic coverage in the output image that what is in the Map Control 
            (basically the Scale of the Map Control is different than that of the <b>Data Frame</b> of the 
            <b>Layout Template</b>). Additionally when the Scale that is shown in the Map Control on the client 
            does not match that of the <b>Data Frame</b> in the <b>Layout Template</b>, Layers may or may not 
            draw based upon their scale dependency visibility setting. This may result in an output image that 
            looks very different than what is on the client. How to obtain and use each of the three key pieces 
            of information (listed previously) in order to produce a WYSIWYG printed output specifically for the 
            Map Control will be discussed in more depth as follows:
            </para>
            <para><u>Knowing the DataFrame</u></para>
            <para>
            A <b>Layout Template</b> is a map document (.mxd) that is used to define the placement of a map 
            and marginalia for use by ArcGIS Server to generate an output image. The <b>Data Frame</b> is the 
            placeholder for the map (and it's Layers) within the <b>Layout Template</b>. The default location where 
            the <b>Layout Templates</b> are stored on ArcGIS Server is 
            <b>&lt;install_directory&gt;\Templates\ExportWebMapTemplates</b> (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Default location of Layout Template map documents on ArcGIS Server." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_1.png"/>
            </para>
            <para>
            The filename without the .mxd extension should exactly match the names of the <b>Layout Templates</b> 
            that are listed in <b>Layout_Template</b> parameter of the <b>ArcGIS REST Services Directory</b> under 
            the <b>Choice List</b> option (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Finding Layout Template options in the ArcGIS REST Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_2.png"/>
            </para>
            <para>
            In order to produce a WYSIWYG printed output specifically for the Map Control requires knowing the 
            <b>Data Frame</b> Width and Height in the <b>Layout Template</b>. Using ArcMap, open a particular 
            <b>Layout Template</b> map document (.mxd) and with the <b>Layout View</b> being active, right-click 
            on the <b>Data Frame</b> element and choose <b>Properties...</b> from the context menu (see the 
            following screen shot for opening the ‘Tabloid ANSI B Portrait.mxd’ file):
            </para>
            <para>
            <img border="0" alt="Opening the 'Tabloid ANSI B Portrait.mxd' file and choosing Properties from the context menu for the Data Frame." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_3.png"/>
            </para>
            <para>
            Then click on the <b>Size and Position</b> tab of the <b>Data Frame Properties</b> dialog to obtain 
            the <b>Width</b> and <b>Height</b> arguments (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Obtaining the Width and Height settings of the Data Frame." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_4.png"/>
            </para>
            <para><u>Using a Ratio</u></para>
            <para>
            Because the exact aspect ratio of the Map Control on the client and the <b>Data Frame</b> of the 
            <b>Layout Template</b> on ArcGIS Server will typically not match, this will result in scale 
            differences that will give non-WYSIWYG output. To correct for this, it is necessary to create 
            either <b>Height-to-Width</b> ratio or a <b>Width-to-Height</b> ratio using the results of the 
            <b>Height</b> and <b>Width</b> arguments of the <b>Data Frame</b>. This ratio will then be used 
            to adjust either the <b>Height</b> or <b>Width</b> of the Map Control in the client application 
            and thereby ensure that what geographic coverage is in the Map Control exactly matches the 
            <b>Data Frame</b> in the <b>Layout Template</b>. The following provides the generic algorithm 
            for applying the ratio (only one is needed in your application):
            </para>
            <code>
            DataFrame.Height = X (&lt;-- some static value)
            DataFrame.Width = Y (&lt;-- some static value)
            MapControl.Height = Z (&lt;-- some static value)
            MapControl.Width = MapControl.Height * (DataFrame.Width / DataFrame.Height)
            </code>
            OR
            <code>
            DataFrame.Height = X (&lt;-- some static value)
            DataFrame.Width = Y (&lt;-- some static value)
            MapControl.Width = Z (&lt;-- some static value)
            MapControl.Height = MapControl.Width * (DataFrame.Height / DataFrame.Width) 
            </code>
            <para><u>Ensuring No Scale Dependency Layers</u></para>
            <para>
            Because the physical size of the Map Control in the client application and the <b>Data Frame</b> 
            in the <b>Layout Template</b> will most likely not be exactly the same, the Scale will be different. 
            While the Extent of the geographic coverage of the Layers in between the Map Control and the 
            <b>Data Frame</b> may be the same (especially since you made sure the ratio between the two is the 
            same), because the physical size of the two elements is different the Scale will also be inherently 
            different. When Layers (or any sub-Layers) that have scale dependent visibility applied as you zoom 
            in/out, the geographic features that are displayed could change. As a safety precaution to ensure 
            WYSIWYG compliance, it is best that no scale dependency is set on any Layers that are desired to be 
            visible in the Map Control. Examining the <b>ArcGIS REST Services Directory</b> for the <b>Url</b> 
            of the web service for each Layer you can ensure that the <b>Min. Scale</b> and <b>Max. Scale</b> 
            attributes are both zero (0) (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Ensuring there are no scale dependency layers using the ArcGIS Rest Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_5.png"/>
            </para>
            <para>
            If it turns out that non-zero value are present in the web service, it may be necessary to re-author 
            the ArcMap map document (.mxd) and re-publish the web service on ArcGIS Server. Setting the scale 
            dependency visibility in ArcMap is done in the <b>General</b> tab of the <b>Layer Properties</b> 
            dialog; look for the <b>Scale Range</b> section (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Setting the 'Show layer at all scales' radio button in the Layer Properties of an authored web service helps ensure WYSIWYG printing." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_6.png"/>
            </para>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            When the application loads, all available Layout Templates that are supported for the PrintTask are 
            listed in the ListBox. Click on a particular Layout Template and the Map Control will appear with 
            the Height and Width of the Control adjusted to match the same ratio as the Data Frame of the Layout 
            Template on the ArcGIS Server machine. This helps to ensure WYSIWYG printing.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Creating WYSIWYG prints of the Map Control via the PrintTask." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_7.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="13,288,0,0" Visibility="Collapsed"
                        Name="MyMap" VerticalAlignment="Top" WrapAround="True" Height="300" Width="600"
                         Extent="-14130480,2889032,-7273626,6317460" BorderBrush="Black" BorderThickness="1"&gt;
                &lt;esri:Map.Layers&gt;
                  &lt;esri:LayerCollection&gt;
                  
                    &lt;!-- Add a layer to the Map Control. --&gt;
                    &lt;esri:ArcGISDynamicMapServiceLayer ID="MyArcGISDynamicMapServiceLayer"
                      Url="http://services.arcgisonline.com/ArcGIS/rest/services/World_Physical_Map/MapServer"/&gt;
                    
                  &lt;/esri:LayerCollection&gt;
                &lt;/esri:Map.Layers&gt;
              &lt;/esri:Map&gt;
              
              &lt;!-- Url --&gt;
              &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="605" FontSize="10" /&gt;
              
              &lt;!-- Button to perform the work. --&gt;
              &lt;Button Content="ExecuteAsync" Height="25" Width="229" HorizontalAlignment="Left" Margin="12,147,0,0" 
                      Name="Button_ExecuteAsync" VerticalAlignment="Top" Click="Button_ExecuteAsync_Click" IsEnabled="True"/&gt;
              
              &lt;!-- Provide Width, Height, and their ratio information about the Data Frame and Map Control. --&gt;
              &lt;sdk:Label Height="19" Margin="31,178,483,0" Name="Label_DataFrameHeight" 
                         VerticalAlignment="Top" Content="Data Frame Height:" /&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="141,178,0,0" Name="TextBlock_DataFrameHeight" 
                         Text="" VerticalAlignment="Top" Width="100" /&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="36,197,0,0" Name="Label_DataFrameWidth" 
                         VerticalAlignment="Top" Width="103" Content="Data Frame Width:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="141,196,0,0" Name="TextBlock_DataFrameWidth" 
                         Text="" VerticalAlignment="Top" Width="100" /&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="29,216,0,0" Name="Label_MapControlHeight" 
                         VerticalAlignment="Top" Width="111" Content="Map Control Height:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="141,215,0,0" Name="TextBlock_MapControlHeight" 
                         Text="" VerticalAlignment="Top" Width="100" /&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="33,234,0,0" Name="Label_MapControlWidth" 
                         VerticalAlignment="Top" Width="109" Content="Map Control Width:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="141,233,0,0" Name="TextBlock_MapControlWidth" 
                         Text="" VerticalAlignment="Top" Width="100" /&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="13,253,0,0" Name="Label_RatioWidthToHeight" 
                         VerticalAlignment="Top" Width="126" Content="Ratio Width To Height:"/&gt;
              &lt;TextBlock Height="19" HorizontalAlignment="Left" Margin="141,251,0,0" Name="TextBlock_RatioWidthToHeight" 
                         Text="" VerticalAlignment="Top" Width="100" /&gt;
              
              &lt;!-- Display all of the available Layout Template printing options from the PrintTask web service. --&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="288,144,0,0" Name="Label_LayoutTemplate" 
                         VerticalAlignment="Top" Width="98" Content="Layout Tempate:" /&gt;
              &lt;ListBox Height="110" HorizontalAlignment="Left" Margin="288,160,0,0" Name="ListBox_LayoutTemplate" 
                        VerticalAlignment="Top" Width="226" SelectionChanged="ListBox_LayoutTemplate_SelectionChanged"/&gt;
              
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="94" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="625" 
                 TextWrapping="Wrap" Text="When the application loads, all available Layout Templates that are supported 
                 for the PrintTask are listed in the ListBox. Click on a particular Layout Template and the Map Control 
                 will appear with the Height and Width of the Control adjusted to match the same ratio as the Data Frame 
                 of the Layout Template on the ArcGIS Server machine. This helps to ensure WYSIWYG printing." /&gt;
              
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            // Create Global (aka. Member) variables for the PrintTask and a Dictionary objects that will be 
            // used in other parts of the application.
            public ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            public Dictionary&lt;string, DataFrameAndMapControlInfo&gt; _StaticDataFrameAndMapControlInfo = new Dictionary&lt;string, DataFrameAndMapControlInfo&gt;();
              
            // Create a custom Class that will hold information necessary to facilitate WYSIWYG printing of the
            // client application Map Control using a Layout Template on ArcGIS Server. Information about the 
            // Width and Height of the Data Frame of the Layout Templates on the ArcGIS Server Machine is stored.
            // A ratio of Width to Height is stored. Also the size (Width and Height) of the Map Contol is stored. 
            public class DataFrameAndMapControlInfo
            {
              public string Name;
              public double DataFrame_Width;
              public double DataFrame_Height;
              public double Ratio_WidthToHeight;
              public double MapControl_Width;
              public double MapControl_Height;
            }
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = true;
              
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the PrintTask.GetServiceInfoCompleted Event.
              _PrintTask.GetServiceInfoCompleted += printTask_GetServiceInfoCompleted;
              
              // Call the PrintTask.GetServiceInfoAsync Method which will give information about the PrintTask
              // web service (via the PrintServiceInfo Class). Especially useful to find what Layout Templates
              // are supported in the web service.
              _PrintTask.GetServiceInfoAsync();
              
              // Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              _PrintTask.ExecuteCompleted += printTask_ExecuteCompleted;
              
              // Call a custom function to store all of the hard coded values about the Data Frame element in 
              // the Layout Template as well as information about the Map Control in the client application.
              PopulateStaticDataFrameInfo();
            }
            
            private void printTask_GetServiceInfoCompleted(object sender, ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs e)
            {
              // Gets information about the PrintTask web service.
              
              // Get the PrintServiceInfo object.
              ESRI.ArcGIS.Client.Printing.PrintServiceInfo myPrintServiceInfo = e.ServiceInfo;
              
              // Get the IEnumerable of the Layout Template names available on the PrintTask web service.
              IEnumerable&lt;string&gt; myLayoutTemplates = myPrintServiceInfo.LayoutTemplates;
              
              // Loop through all of the names of the Layout Templates and add them to the ListBox.
              foreach (string myLayoutTemplate in myLayoutTemplates)
              {
                ListBox_LayoutTemplate.Items.Add(myLayoutTemplate);
              }
            }
            
            public void PopulateStaticDataFrameInfo()
            {
              // This is a custom function to store all of the hard coded values about the Data Frame element in 
              // the Layout Template as well as information about the Map Control in the client application.
              //
              // The DataFrameAndMapControlInfo.DataFrame_Height and DataFrameAndMapControlInfo.DataFrame_Width 
              // hardcoded variables were obtained by opening the Layout Template map document (.mxd) file on 
              // the ArcGIS Server machine. The default location where the Layout Templates are stored on ArcGIS 
              // Server is &lt;nstall_directory&gt;\Templates\ExportWebMapTemplates. The filename of the Layout Template
              // map document (without the .mxd extension) should match the names of the Layout Templates returned
              // from the PrintTask.GetServiceInfoCompleted Event.
              //
              // The DataFrameAndMapControlInfo.Ratio_WidthToHeight variables are calcualted to figure out the
              // ratio of the Width to Height of the Data Frame. This will then be used to calculate the Width
              // of the Map Control on the client application such that the ratio of Height to Width in the Data 
              // Frame matches the ratio of Height to Width in the Map Control. This is the key to getting a
              // WYSIWYG printing of the Map Control in the output returned from the PrintTask.
              
              DataFrameAndMapControlInfo x = new DataFrameAndMapControlInfo();
              x.Name = "MAP_ONLY";
              x.DataFrame_Height = 4.167;
              x.DataFrame_Width = 4.167;
              x.Ratio_WidthToHeight = x.DataFrame_Width / x.DataFrame_Height;
              x.MapControl_Height = 400;
              x.MapControl_Width = x.MapControl_Height * x.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x.Name, x);
              
              DataFrameAndMapControlInfo x1 = new DataFrameAndMapControlInfo();
              x1.Name = "A3 Landscape";
              x1.DataFrame_Height = 21.1688;
              x1.DataFrame_Width = 39.9998;
              x1.Ratio_WidthToHeight = x1.DataFrame_Width / x1.DataFrame_Height;
              x1.MapControl_Height = 400;
              x1.MapControl_Width = x1.MapControl_Height * x1.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x1.Name, x1);
              
              DataFrameAndMapControlInfo x2 = new DataFrameAndMapControlInfo();
              x2.Name = "A3 Portrait";
              x2.DataFrame_Height = 29.0002;
              x2.DataFrame_Width = 27.6756;
              x2.Ratio_WidthToHeight = x2.DataFrame_Width / x2.DataFrame_Height;
              x2.MapControl_Height = 400;
              x2.MapControl_Width = x2.MapControl_Height * x2.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x2.Name, x2);
              
              DataFrameAndMapControlInfo x3 = new DataFrameAndMapControlInfo();
              x3.Name = "A4 Landscape";
              x3.DataFrame_Height = 15.918;
              x3.DataFrame_Width = 27.7564;
              x3.Ratio_WidthToHeight = x3.DataFrame_Width / x3.DataFrame_Height;
              x3.MapControl_Height = 400;
              x3.MapControl_Width = x3.MapControl_Height * x3.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x3.Name, x3);
              
              DataFrameAndMapControlInfo x4 = new DataFrameAndMapControlInfo();
              x4.Name = "A4 Portrait";
              x4.DataFrame_Height = 22.285;
              x4.DataFrame_Width = 19.024;
              x4.Ratio_WidthToHeight = x4.DataFrame_Width / x4.DataFrame_Height;
              x4.MapControl_Height = 400;
              x4.MapControl_Width = x4.MapControl_Height * x4.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x4.Name, x4);
              
              DataFrameAndMapControlInfo x5 = new DataFrameAndMapControlInfo();
              x5.Name = "Letter ANSI A Landscape";
              x5.DataFrame_Height = 6.25;
              x5.DataFrame_Width = 10;
              x5.Ratio_WidthToHeight = x5.DataFrame_Width / x5.DataFrame_Height;
              x5.MapControl_Height = 400;
              x5.MapControl_Width = x5.MapControl_Height * x5.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x5.Name, x5);
              
              DataFrameAndMapControlInfo x6 = new DataFrameAndMapControlInfo();
              x6.Name = "Letter ANSI A Portrait";
              x6.DataFrame_Height = 8;
              x6.DataFrame_Width = 7.5;
              x6.Ratio_WidthToHeight = x6.DataFrame_Width / x6.DataFrame_Height;
              x6.MapControl_Height = 400;
              x6.MapControl_Width = x6.MapControl_Height * x6.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x6.Name, x6);
              
              DataFrameAndMapControlInfo x7 = new DataFrameAndMapControlInfo();
              x7.Name = "Tabloid ANSI B Landscape";
              x7.DataFrame_Height = 7.7571;
              x7.DataFrame_Width = 16;
              x7.Ratio_WidthToHeight = x7.DataFrame_Width / x7.DataFrame_Height;
              x7.MapControl_Height = 400;
              x7.MapControl_Width = x7.MapControl_Height * x7.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x7.Name, x7);
              
              DataFrameAndMapControlInfo x8 = new DataFrameAndMapControlInfo();
              x8.Name = "Tabloid ANSI B Portrait";
              x8.DataFrame_Height = 11.75;
              x8.DataFrame_Width = 10;
              x8.Ratio_WidthToHeight = x8.DataFrame_Width / x8.DataFrame_Height;
              x8.MapControl_Height = 400;
              x8.MapControl_Width = x8.MapControl_Height * x8.Ratio_WidthToHeight;
              _StaticDataFrameAndMapControlInfo.Add(x8.Name, x8);
            }
            
            private void ListBox_LayoutTemplate_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
            {
              // The user clicked on a Layout Template name in the ListBox.
              
              // Make the Map Control visible.
              MyMap.Visibility = Windows.Visibility.Visible;
              
              // Get the user selected Layout Template name.
              string theChoice = ListBox_LayoutTemplate.SelectedItem;
              
              // Find the correct DataFrameAndMapControlInfo object which contains static information about
              // the Data Frame and Map Control.
              DataFrameAndMapControlInfo oneDataFrameInfo = _StaticDataFrameAndMapControlInfo[theChoice];
              
              // Adjust the Height and Width of the Map Control to match the same ratio as the Data Frame in the
              // Layout Template.
              MyMap.Height = oneDataFrameInfo.MapControl_Height;
              MyMap.Width = oneDataFrameInfo.MapControl_Width;
              
              // Display the static information in the DataFrameAndMapControlInfo to the user.
              TextBlock_DataFrameHeight.Text = oneDataFrameInfo.DataFrame_Height.ToString();
              TextBlock_DataFrameWidth.Text = oneDataFrameInfo.DataFrame_Width.ToString();
              TextBlock_MapControlHeight.Text = oneDataFrameInfo.MapControl_Height.ToString();
              TextBlock_MapControlWidth.Text = oneDataFrameInfo.MapControl_Width.ToString();
              TextBlock_RatioWidthToHeight.Text = oneDataFrameInfo.Ratio_WidthToHeight.ToString();
            }
            
            private void Button_ExecuteAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // The user clicked the button to generate an output map image.
              
              // Get the user selected Layout Template name.
              string theChoice = ListBox_LayoutTemplate.SelectedItem;
              
              // Find the correct DataFrameAndMapControlInfo object which contains static information about
              // the Data Frame and Map Control.
              DataFrameAndMapControlInfo oneDataFrameInfo = _StaticDataFrameAndMapControlInfo[theChoice];
              
              // Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              // Define the PrintParameters.
              ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
              myPrintParameters.LayoutTemplate = oneDataFrameInfo.Name;
              myPrintParameters.Format = "JPG"; // Look to the REST service to see what image formats are supported.
              
              // Define the MapOptions. It is imperative that this Class be used but only the Map.Extent be provided
              // (either via the constructor or via the Property). Do not set the MapOptions.Scale Property! We want 
              // the PrintTask on ArcGIS Server to maintain the same Extent between the Map Control and the Data Frame
              // in the Layout Template, the Scale on ArcGIS server will be adjusted according to the Extent and the
              // size of the Data Frame in the Layout Template.
              ESRI.ArcGIS.Client.Printing.MapOptions myMapOptions = new ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent);
              myPrintParameters.MapOptions = myMapOptions;
              
              // NOTE: 
              // If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              // using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              // NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              // the pending request or wait for it to complete." 
              // In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              if (_PrintTask.IsBusy == true)
              {
                // There is an existing 'synchronous geoprocessing task' PrintTask running. 
                // Wait a few moments for the output to be generated and click the button again.
              }
              else if (_PrintTask.IsBusy == false)
              {
                // There is not an existing 'synchronous geoprocessing task' PrintTask running.
                 
                // Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                _PrintTask.ExecuteAsync(myPrintParameters);
              }
            }
            
            private void printTask_ExecuteCompleted(object sender, ESRI.ArcGIS.Client.Printing.PrintEventArgs e)
            {
              // Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              // Get any error information (add your own enhancements if desired). 
              System.Exception mySystemException = e.Error;
              
              // Get the PrintResult from the completed operation.
              ESRI.ArcGIS.Client.Printing.PrintResult myPrintResult = e.PrintResult;
              
              // Test is we have valid return PrintResults.
              if (myPrintResult != null)
              {
                // Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                List&lt;ESRI.ArcGIS.Client.Tasks.GPMessage&gt; myListOfGPMessage = myPrintResult.Messages;
                
                // Get the location of the image/.pdf created by ArcGIS Server.
                System.Uri myUri = myPrintResult.Url;
                
                // Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank");
              }
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create Global (aka. Member) variables for the PrintTask and a Dictionary objects that will be 
            ' used in other parts of the application.
            Public _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
            Public _StaticDataFrameAndMapControlInfo As New Dictionary(Of String, DataFrameAndMapControlInfo)
            
            ' Create a custom Class that will hold information necessary to facilitate WYSIWYG printing of the
            ' client application Map Control using a Layout Template on ArcGIS Server. Information about the 
            ' Width and Height of the Data Frame of the Layout Templates on the ArcGIS Server Machine is stored.
            ' A ratio of Width to Height is stored. Also the size (Width and Height) of the Map Contol is stored. 
            Public Class DataFrameAndMapControlInfo
              Public Name As String
              Public DataFrame_Width As Double
              Public DataFrame_Height As Double
              Public Ratio_WidthToHeight As Double
              Public MapControl_Width As Double
              Public MapControl_Height As Double
            End Class
            
            Public Sub New()
              
              InitializeComponent()
               
              ' Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
               _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = True
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the PrintTask.GetServiceInfoCompleted Event.
              AddHandler _PrintTask.GetServiceInfoCompleted, AddressOf printTask_GetServiceInfoCompleted
              
              ' Call the PrintTask.GetServiceInfoAsync Method which will give information about the PrintTask
              ' web service (via the PrintServiceInfo Class). Especially useful to find what Layout Templates
              ' are supported in the web service.
              _PrintTask.GetServiceInfoAsync()
              
              ' Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              AddHandler _PrintTask.ExecuteCompleted, AddressOf printTask_ExecuteCompleted
              
              ' Call a custom function to store all of the hard coded values about the Data Frame element in 
              ' the Layout Template as well as information about the Map Control in the client application.
              PopulateStaticDataFrameInfo()
              
            End Sub
              
            Private Sub printTask_GetServiceInfoCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs)
              
              ' Gets information about the PrintTask web service.
              
              ' Get the PrintServiceInfo object.
              Dim myPrintServiceInfo As ESRI.ArcGIS.Client.Printing.PrintServiceInfo = e.ServiceInfo
              
              ' Get the IEnumerable of the Layout Template names available on the PrintTask web service.
              Dim myLayoutTemplates As IEnumerable(Of String) = myPrintServiceInfo.LayoutTemplates
              
              ' Loop through all of the names of the Layout Templates and add them to the ListBox.
              For Each myLayoutTemplate As String In myLayoutTemplates
                ListBox_LayoutTemplate.Items.Add(myLayoutTemplate)
              Next
              
            End Sub
            
            Public Sub PopulateStaticDataFrameInfo()
              
              ' This is a custom function to store all of the hard coded values about the Data Frame element in 
              ' the Layout Template as well as information about the Map Control in the client application.
              '
              ' The DataFrameAndMapControlInfo.DataFrame_Height and DataFrameAndMapControlInfo.DataFrame_Width 
              ' hardcoded variables were obtained by opening the Layout Template map document (.mxd) file on 
              ' the ArcGIS Server machine. The default location where the Layout Templates are stored on ArcGIS 
              ' Server is &lt;install_directory&gt;\Templates\ExportWebMapTemplates. The filename of the Layout Template
              ' map document (without the .mxd extension) should match the names of the Layout Templates returned
              ' from the PrintTask.GetServiceInfoCompleted Event.
              '
              ' The DataFrameAndMapControlInfo.Ratio_WidthToHeight variables are calcualted to figure out the
              ' ratio of the Width to Height of the Data Frame. This will then be used to calculate the Width
              ' of the Map Control on the client application such that the ratio of Height to Width in the Data 
              ' Frame matches the ratio of Height to Width in the Map Control. This is the key to getting a
              ' WYSIWYG printing of the Map Control in the output returned from the PrintTask.
              
              Dim x As New DataFrameAndMapControlInfo
              x.Name = "MAP_ONLY"
              x.DataFrame_Height = 4.167
              x.DataFrame_Width = 4.167
              x.Ratio_WidthToHeight = x.DataFrame_Width / x.DataFrame_Height
              x.MapControl_Height = 400
              x.MapControl_Width = x.MapControl_Height * x.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x.Name, x)
              
              Dim x1 As New DataFrameAndMapControlInfo
              x1.Name = "A3 Landscape"
              x1.DataFrame_Height = 21.1688
              x1.DataFrame_Width = 39.9998
              x1.Ratio_WidthToHeight = x1.DataFrame_Width / x1.DataFrame_Height
              x1.MapControl_Height = 400
              x1.MapControl_Width = x1.MapControl_Height * x1.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x1.Name, x1)
              
              Dim x2 As New DataFrameAndMapControlInfo
              x2.Name = "A3 Portrait"
              x2.DataFrame_Height = 29.0002
              x2.DataFrame_Width = 27.6756
              x2.Ratio_WidthToHeight = x2.DataFrame_Width / x2.DataFrame_Height
              x2.MapControl_Height = 400
              x2.MapControl_Width = x2.MapControl_Height * x2.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x2.Name, x2)
              
              Dim x3 As New DataFrameAndMapControlInfo
              x3.Name = "A4 Landscape"
              x3.DataFrame_Height = 15.918
              x3.DataFrame_Width = 27.7564
              x3.Ratio_WidthToHeight = x3.DataFrame_Width / x3.DataFrame_Height
              x3.MapControl_Height = 400
              x3.MapControl_Width = x3.MapControl_Height * x3.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x3.Name, x3)
              
              Dim x4 As New DataFrameAndMapControlInfo
              x4.Name = "A4 Portrait"
              x4.DataFrame_Height = 22.285
              x4.DataFrame_Width = 19.024
              x4.Ratio_WidthToHeight = x4.DataFrame_Width / x4.DataFrame_Height
              x4.MapControl_Height = 400
              x4.MapControl_Width = x4.MapControl_Height * x4.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x4.Name, x4)
              
              Dim x5 As New DataFrameAndMapControlInfo
              x5.Name = "Letter ANSI A Landscape"
              x5.DataFrame_Height = 6.25
              x5.DataFrame_Width = 10
              x5.Ratio_WidthToHeight = x5.DataFrame_Width / x5.DataFrame_Height
              x5.MapControl_Height = 400
              x5.MapControl_Width = x5.MapControl_Height * x5.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x5.Name, x5)
              
              Dim x6 As New DataFrameAndMapControlInfo
              x6.Name = "Letter ANSI A Portrait"
              x6.DataFrame_Height = 8
              x6.DataFrame_Width = 7.5
              x6.Ratio_WidthToHeight = x6.DataFrame_Width / x6.DataFrame_Height
              x6.MapControl_Height = 400
              x6.MapControl_Width = x6.MapControl_Height * x6.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x6.Name, x6)
              
              Dim x7 As New DataFrameAndMapControlInfo
              x7.Name = "Tabloid ANSI B Landscape"
              x7.DataFrame_Height = 7.7571
              x7.DataFrame_Width = 16
              x7.Ratio_WidthToHeight = x7.DataFrame_Width / x7.DataFrame_Height
              x7.MapControl_Height = 400
              x7.MapControl_Width = x7.MapControl_Height * x7.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x7.Name, x7)
              
              Dim x8 As New DataFrameAndMapControlInfo
              x8.Name = "Tabloid ANSI B Portrait"
              x8.DataFrame_Height = 11.75
              x8.DataFrame_Width = 10
              x8.Ratio_WidthToHeight = x8.DataFrame_Width / x8.DataFrame_Height
              x8.MapControl_Height = 400
              x8.MapControl_Width = x8.MapControl_Height * x8.Ratio_WidthToHeight
              _StaticDataFrameAndMapControlInfo.Add(x8.Name, x8)
              
            End Sub
            
            Private Sub ListBox_LayoutTemplate_SelectionChanged(sender As System.Object, e As System.Windows.Controls.SelectionChangedEventArgs)
              
              ' The user clicked on a Layout Template name in the ListBox.
              
              ' Make the Map Control visible.
              MyMap.Visibility = Windows.Visibility.Visible
              
              ' Get the user selected Layout Template name.
              Dim theChoice As String = ListBox_LayoutTemplate.SelectedItem
              
              ' Find the correct DataFrameAndMapControlInfo object which contains static information about
              ' the Data Frame and Map Control.
              Dim oneDataFrameInfo As DataFrameAndMapControlInfo = _StaticDataFrameAndMapControlInfo.Item(theChoice)
              
              ' Adjust the Height and Width of the Map Control to match the same ratio as the Data Frame in the
              ' Layout Template.
              MyMap.Height = oneDataFrameInfo.MapControl_Height
              MyMap.Width = oneDataFrameInfo.MapControl_Width
              
              ' Display the static information in the DataFrameAndMapControlInfo to the user.
              TextBlock_DataFrameHeight.Text = oneDataFrameInfo.DataFrame_Height.ToString
              TextBlock_DataFrameWidth.Text = oneDataFrameInfo.DataFrame_Width.ToString
              TextBlock_MapControlHeight.Text = oneDataFrameInfo.MapControl_Height.ToString
              TextBlock_MapControlWidth.Text = oneDataFrameInfo.MapControl_Width.ToString
              TextBlock_RatioWidthToHeight.Text = oneDataFrameInfo.Ratio_WidthToHeight.ToString
              
            End Sub
              
            Private Sub Button_ExecuteAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' The user clicked the button to generate an output map image.
              
              ' Get the user selected Layout Template name.
              Dim theChoice As String = ListBox_LayoutTemplate.SelectedItem
              
              ' Find the correct DataFrameAndMapControlInfo object which contains static information about
              ' the Data Frame and Map Control.
              Dim oneDataFrameInfo As DataFrameAndMapControlInfo = _StaticDataFrameAndMapControlInfo.Item(theChoice)
              
              ' Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              ' Define the PrintParameters.
              Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
              myPrintParameters.LayoutTemplate = oneDataFrameInfo.Name
              myPrintParameters.Format = "JPG" ' Look to the REST service to see what image formats are supported.
              
              ' Define the MapOptions. It is imperative that this Class be used but only the Map.Extent be provided
              ' (either via the constructor or via the Property). Do not set the MapOptions.Scale Property! We want 
              ' the PrintTask on ArcGIS Server to maintain the same Extent between the Map Control and the Data Frame
              ' in the Layout Template, the Scale on ArcGIS server will be adjusted according to the Extent and the
              ' size of the Data Frame in the Layout Template.
              Dim myMapOptions As New ESRI.ArcGIS.Client.Printing.MapOptions(MyMap.Extent)
              myPrintParameters.MapOptions = myMapOptions
              
              ' NOTE: 
              ' If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              ' using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              ' NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              ' the pending request or wait for it to complete." 
              ' In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              If _PrintTask.IsBusy = True Then
                
                ' There is an existing 'synchronous geoprocessing task' PrintTask running. 
                ' Wait a few moments for the output to be generated and click the button again.
                
              ElseIf _PrintTask.IsBusy = False Then
                
                ' There is not an existing 'synchronous geoprocessing task' PrintTask running.
                
                ' Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                _PrintTask.ExecuteAsync(myPrintParameters)
                
              End If
              
            End Sub
            
            Private Sub printTask_ExecuteCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.PrintEventArgs)
              
              ' Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              ' Get any error information (add your own enhancements if desired). 
              Dim mySystemException As System.Exception = e.Error
              
              ' Get the PrintResult from the completed operation.
              Dim myPrintResult As ESRI.ArcGIS.Client.Printing.PrintResult = e.PrintResult
              
              ' Test is we have valid return PrintResults.
              If myPrintResult IsNot Nothing Then
                
                ' Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                Dim myListOfGPMessage As List(Of ESRI.ArcGIS.Client.Tasks.GPMessage) = myPrintResult.Messages
                
                ' Get the location of the image/.pdf created by ArcGIS Server.
                Dim myUri As System.Uri = myPrintResult.Url
                
                ' Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank")
                
              End If
              
            End Sub
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.MapOptions.#ctor(ESRI.ArcGIS.Client.Geometry.Envelope)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.MapOptions"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.MapOptions.#ctor(ESRI.ArcGIS.Client.Map)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.MapOptions"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.MapOptions.Extent">
            <summary>
            Gets the map's extent.
            Required. 
            Can be determined based on PrintParameter Map/Layers.
            </summary>
            <value>The map's extent.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.MapOptions.OutSpatialReference">
            <summary>
            Gets or sets the output spatial reference used for exporting map.
            Optional. If not specified, spatial reference of MapOptions.Extent will be used.
            </summary>
            <value>The spatial reference.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.MapOptions.Scale">
            <summary>
            Gets or sets the map's scale.
            Optional but recommended for scale-dependent layers or reference scales set.
            Can be determined based on PrintParameter Map/Layers.
            Takes precedence over Extent. 
            Output map is drawn at requested scale centered on the center of extent.
            </summary>
            <value>The map's scale.</value>		
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.MapOptions.Rotation">
            <summary>
            Gets or sets the map's rotation.
            Optional.
            </summary>
            <value>The rotation.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.MapOptions.TimeExtent">
            <summary>
            Gets or sets the map's time extent.
            Optional, required only when time-aware layer need to be drawn at specific time extent.
            Represents start and end time or a time instant in UTC.
            </summary>
            <value>The map's time extent.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintParameters">
            <summary>
            The parameters used to execute a print task.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintParameters.#ctor(ESRI.ArcGIS.Client.Map)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintParameters"/> class.
            </summary>
            <param name="map">The map.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintParameters.#ctor(System.Collections.Generic.IEnumerable{ESRI.ArcGIS.Client.Layer},ESRI.ArcGIS.Client.Geometry.Envelope)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintParameters"/> class.
            </summary>
            <param name="layers">The layers.</param>
            <param name="mapExtent">The map extent.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintParameters.ToJson">
            <summary>
            Serializes PrintParameters to JSON
            </summary>
            <returns>
            A JSON string representation of PrintParameters
            </returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.Map">
            <summary>
            Gets or sets the map.
            Takes precedence over Layers.
            Not needed if Layers is specified.
            </summary>
            <value>The map.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.MapOptions">
            <summary>
            Gets or sets the map options.
            Required.
            Defines map display properties.
            </summary>
            <value>The map options.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.ExportOptions">
            <summary>
            Gets or sets the export options.
            Required only if LayoutTemplate is empty or MAP_ONLY
            </summary>
            <value>The export options.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutOptions">
            <summary>
            Gets or sets the layout options.
            Optional.
            Used to replace page layout elements.
            </summary>
            <value>The layout options.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutTemplate">
            <summary>
            Gets or sets the layout template.
            Required by server and client
            </summary>
            <value>The layout template.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.Format">
            <summary>
            Gets or sets the format.
            Required by server and client
            </summary>
            <value>The format.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintParameters.CustomInputParameters">
            <summary>
            Gets or sets the custom input parameters.
            </summary>
            <value>The custom input parameters.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintResult">
            <summary>
            Print result
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintResult.#ctor(System.Uri,System.Collections.Generic.List{ESRI.ArcGIS.Client.Tasks.GPMessage},System.Collections.Generic.IEnumerable{ESRI.ArcGIS.Client.Tasks.GPParameter})">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintResult"/> class.
            </summary>
            <param name="uri">The URI.</param>
            <param name="messages">The messages.</param>
            <param name="customOutputParameters">The custom output parameters.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintResult.Url">
            <summary>
            Gets the URL location of the output map.
            </summary>
            <value>The URL location of the output map.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintResult.OutputParameters">
            <summary>
            Gets the output parameters.
            </summary>
            <value>The output parameters.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintResult.Messages">
            <summary>
            Gets the output messages from PrintTask
            </summary>
            <value>The output messages.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintServiceInfo">
            <summary>
            Print Service information
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintServiceInfo.#ctor(System.Collections.Generic.IEnumerable{System.String},System.Collections.Generic.IEnumerable{System.String},System.Boolean,System.Collections.Generic.IEnumerable{ESRI.ArcGIS.Client.Tasks.ParameterInfo})">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintServiceInfo"/> class.
            </summary>
            <param name="layoutTemplates">The layout templates.</param>
            <param name="formats">The formats.</param>
            <param name="isServiceAsynchronous">if set to <c>true</c> if service is asynchronous.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintServiceInfo.LayoutTemplates">
            <summary>
            Gets the layout templates.
            </summary>
            <value>The layout templates.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintServiceInfo.Formats">
            <summary>
            Gets the formats.
            </summary>
            <value>The formats.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintServiceInfo.Parameters">
            <summary>
            Gets the parameters.
            </summary>
            <value>The parameters.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintServiceInfo.IsServiceAsynchronous">
            <summary>
            Gets a value indicating whether the service is asynchronous.
            </summary>
            When true, use  <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)"/>;
            otherwise, use <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)"/>.
            <value>
            	<c>true</c> if the service is asynchronous; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.PrintTask">
            <summary>
             Task for exporting map for printing.
            </summary>
            <remarks>
            <para>
            Printing of the ArcGIS Map Control contents is accomplished via the ESRI.ArcGIS.Client.Printing.PrintTask Class. 
            It is not printing directly to a device such as a printer or plotter, rather the PrintTask Class is used to 
            generate an image for Printing. PrintTask operations are new as part of ArcGIS Server 10.1 and the 
            ArcGIS API 3.0 for Silverlight.
            
            
            </para>
            <para><b><u>Synchronous -vs- Asynchronous Geoprocessing Tasks</u></b></para>
            <para>
            When it comes to using the PrintTask in web development using the 
            ArcGIS API for Silverlight
            
            
             to generate an image on ArcGIS Server, as a developer you have two options: <b>synchronous geoprocessing tasks</b> 
            and <b>asynchronous geoprocessing tasks</b>. In a traditional sense the terms "synchronous" means that your 
            computer will wait while a process executes on the server and "asynchronous" means that your computer does 
            not have to wait for the process to finish execution and you can move on to other operations. However in 
            web development using 
            Silverlight,
            
            
             all web requests are asynchronous in nature, meaning 
            that once a web request has initiated you are free to perform other operations/functionality in your 
            application as it remains highly responsive. When it comes to the PrintTask there are some important
            differences between the <b>synchronous geoprocessing tasks</b> and <b>asynchronous geoprocessing tasks</b> 
            that are outlined as follows:
            </para>
            <list type="bullet">
            <item>
            A <b>synchronous geoprocessing task</b> means that once ArcGIS Server starts the task to generate the image, 
            ArcGIS Server is dedicated to that operation until it completes. It should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>synchronous geoprocessing task</b> 
            has been initiated you are still free to perform other operations as the application remains highly responsive. 
            See the code example in the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.ExecuteAsync(PrintParameters,Object)</see> 
            Method for how a <b>synchronous geoprocessing task</b> works.
            </item>
            <item>
            An <b>asynchronous geoprocessing task</b> means that ArcGIS Server will control when it can handle generating 
            an image based upon its computing load and will multi-task multiple operations simultaneously until the 
            operation is complete. Again it should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>asynchronous geoprocessing task</b> has been initiated you are 
            still free to perform other operations as the application remains highly responsive. See the code example in the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.SubmitJobAsync</see> Method 
            Method for how an <b>asynchronous geoprocessing task</b> works.
            </item>
            </list>
            <para>
            When constructing a PrintTask the following Types are used by both the <b>synchronous geoprocessing tasks</b> 
            or <b>asynchronous geoprocessing tasks</b>: 
            </para>
            <list type="bullet">
            <item>
            <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask">PrintTask</see> Constructor
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.DisableClientCaching">DisableClientCaching</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.ProxyURL">ProxyURL</see> Property</item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Token">Token</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">Url</see> Property
            </item>
            </list>
            <para>
            The following table illustrates which PrintTask Types are dedicated exclusively to a 
            <b>synchronous geoprocessing task</b> or an <b>asynchronous geoprocessing task</b>:
            </para>
            <list type="table">  
            <listheader>
            <term1>Synchronous geoprocessing task</term1>
            <term2>Asynchronous geoprocessing task</term2>
            </listheader>  
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelAsync">CancelAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobAsync(System.String)">CancelJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">ExecuteAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobStatusUpdates(System.String)">CancelJobStatusUpdates</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">GetServiceInfoAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">SubmitJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">IsBusy</see> Property</term1>
            <term2><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.UpdateDelay">UpdateDelay</see> Property</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteCompleted">ExecuteCompleted</see> Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">StatusUpdated</see> Event</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">GetServiceInfoCompleted</see>Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted">JobCompleted</see> Event</term2>
            </item>
            </list>
            <para>
            As a developer of a web based 
            Silverlight
            
            
             application, when choosing whether to perform a 
            PrintTask based upon the methodology of <b>synchronous geoprocessing task</b> or an 
            <b>asynchronous geoprocessing task</b>, the following information may be helpful in the decision making process:
            </para>
            <list type="bullet">
            <item>
            <para>
            By default, a <b>synchronous geoprocessing task</b> is created when ArcGIS Server is installed and initially 
            configured. This means that no other work is required on ArcGIS Server to enable using the PrintTask (other 
            than starting the <b>PrintingTools</b>, <b>Geoprocessing Service</b>) by an ArcGIS 
            Silverlight
            
            
             application developer. Typically in ArcGIS Server, this 
            <b>synchronous geoprocessing task</b> is located under in the <b>ArcGIS REST Services Directory</b> in the 
            <b>Utilities</b> folder as an <b>Utilties/ExportWebMap (GPServer)</b> Service. The Task is usually called 
            <b>Export Web Map Task</b> and has an <b>Execution Type</b> of <b>esriExecutionTypeSynchronous</b>. For 
            example, assume for the sample ESRI ArcGIS Server (http://servicesbeta2.esri.com/arcgis/rest/) the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">PrintTask.Url</see> for the 
            <b>synchronous geoprocessing task</b> would be as follows (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of the default Export Web Map Task in Synchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeSynchronous.png"/>
            </para>
            </item>
            <item>
            <para>
            For small PrintTask operations using a <b>synchronous geoprocessing task</b> will probably yield faster 
            results in generating a return image/pdf.
            </para>
            </item>
            <item>
            <para>
            A web based 
            Silverlight
            
            
             application can only issue one PrintTask via a 
            <b>synchronous geoprocessing task</b> at a time. This means that it is not possible to have multiple 
            PrintTask operations (i.e. generating multiple image/.pdf files at a time) using a 
            <b>synchronous geoprocessing task</b>. Use the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">PrintTask.IsBusy</see> Property to determine if 
            an existing <b>synchronous geoprocessing task</b> is running before issuing the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">PrintTask.ExecuteAsync</see> 
            Method to avoid the Visual Studio runtime error: <b>NotSupportedException was unhandled by user code</b> 
            ("Task does not support concurrent I/O operations. Cancel the pending request or wait for it to complete"). 
            </para>
            </item>
            <item>
            <para>
            If multiple simultaneous PrintTask operations are necessary from a single web based 
            Silverlight
            
            
             application (i.e. an application that produces numerous images/.pdf for cartographic production), then 
            use the <b>asynchronous geoprocessing task</b> options for better performance.
            </para>
            </item>
            <item>
            <para>
            If the PrintTask operations will be used for very large image/.pdf generation or numerous ArcGIS 
            Silverlight
            
            
             applications will be utilizing a single ArcGIS Server and thereby causing 
            internet browser time-out error messages, then an <b>asynchronous geoprocessing task</b> may be the better 
            choice. It may be possible to increase the amount of time an internet browser waits before a time-out error 
            message occurs when using a <b>synchronous geoprocessing task</b> but this will require testing to 
            determine which option is best for your organization.
            </para>
            </item>
            <item>
            <para>
            Using an <b>asynchronous geoprocessing task</b> requires configuring an ArcGIS Server Geoprocessing Task. 
            This is not done automatically as part of the ArcGIS Server installation/configuration. One option is to use
            ArcMap to run the ArcToolbox: <b>Server Tools</b> | <b>Printing</b> | <b>Export Web Map</b> tool and when 
            the Results are completed right click on the <b>ExportWebMap</b> session and <b>Share As</b> a 
            <b>Geoprocessing Service</b> that can be used by ArcGIS Server. Another option is to use the default 
            ArcGIS Server: <b>Printing Tools</b>, <b>Geoprocessing Service</b> (located in the Utilities folder) that is 
            created when ArcGIS Server is initially installed/configured and change its <b>Execution Mode</b> from Synchronous to 
            Asynchronous (see the following screen shot for an example test ArcGIS Server running on the local 
            developement computer) and re-starting the service:
            </para>
            <para>
            <img border="0" alt="Using ArcGIS Server Manager to change the Execution Mode of an Export Web Map Task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_ArcGISServerManager_ExecutionMode.png"/>
            </para>
            <para>
            This will result in an <b>ArcGIS REST Services Directory</b> page that looks similar to the following 
            screen shot:
            </para>
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of an Export Web Map Task in Asynchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeAsynchronous.png"/>
            </para>
            </item>
            <item>
            <para>
            Using the PrintTask via <b>asynchronous geoprocessing task</b> Types provide much better options to 
            track the status of image/.pdf creation. The 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">PrintTask.StatusUpdated</see> Event uses 
            the <see cref="T:ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs">ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs</see> 
            Class to give instant status information of the operation.
            </para>
            </item>
            </list>
            <para><b><u>Layout Templates</u></b></para>
            <para>
            One common request by ArcGIS developers is the ability to produce a printed map with various marginalia. 
            Marginalia are elements on a map that enhance its viewing and include items such as legends, titles, 
            grids and graticules, scale bars, scale text, north arrows, spatial reference information, additional 
            graphics and text items. For both asynchronous (via the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.SubmitJobAsync</see> 
            Method) and synchronous (via the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">PrintTask.ExecuteAsync</see> 
            Method) geoprocessing tasks on ArcGIS Server, it is the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutOptions">Printing.PrintParameters.LayoutOptions</see> 
            Property that controls the visual representation of the marginalia in the map that is returned from ArcGIS Server. 
            </para>
            <para>
            The <see cref="T:ESRI.ArcGIS.Client.Printing.LayoutOptions">Printing.LayoutOptions</see> Class provides 
            a mechanism to set various marginalia to augment what is seen in the Map Control on a printed map. 
            Depending on the ArcMap graphic <b>Elements</b> in the <b>Layout Template</b> used to generate a printed 
            map via the PrintTask Class, developers can set several LayoutOptions Class Properties to control the 
            marginalia. 
            </para>
            <para>
            Note: An example of producing map with various marginalia using a <b>Layout Template</b> can be found in 
            the example code section of the 
            <see cref="T:ESRI.ArcGIS.Client.Printing.LayoutOptions">Printing.LayoutOptions</see> Class document.
            </para>
            <para>
            A <b>Layout Template</b> is a map document (.mxd) that is used to define the placement of a map 
            and marginalia for use by ArcGIS Server to generate an output image. The default location where 
            the <b>Layout Templates</b> are stored on ArcGIS Server is 
            <b>&lt;install_directory&gt;\Templates\ExportWebMapTemplates</b> (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Default location of Layout Template map documents on ArcGIS Server." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_1.png"/>
            </para>
            <para>
            The filename without the .mxd extension should exactly match the names of the <b>Layout Templates</b> 
            that are listed in <b>Layout_Template</b> parameter of the <b>ArcGIS REST Services Directory</b> under 
            the <b>Choice List</b> option (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Finding Layout Template options in the ArcGIS REST Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_2.png"/>
            </para>
            <para>
            The default <b>Layout Templayes</b> may not make use of every option available in the various LayoutOptions 
            Class Properties. It is the developer’s responsibility to work with the ArcGIS Server manager/administrator 
            to understand what graphic <b>Elements</b> of a specific <b>Layout Template</b> is available for 
            customization via the LayoutOptions Class Properties. The following table provides a list of the ArcMap 
            supported graphic <b>Elements</b> in the <b>Layout Template</b> and how they correspond to the 
            LayoutOptions Class Properties:
            </para>
            <list type="table">  
            <listheader>
              <term>ArcMap graphic Element in the Layout Template</term>
              <description>ESRI.ArcGIS.Client.Printing.LayoutOptions Class Properties</description>
            </listheader>  
            <item>
              <term>Title</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Title">LayoutOptions.Title</see> Property</description>
            </item>
            <item>
              <term>Text</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">LayoutOptions.CustomTextElements</see> Property</description>
            </item>
            <item>
              <term>DynamicText | Author</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.AuthorText">LayoutOptions.AuthorText</see> Property</description>
            </item>
            <item>
              <term>DynamicText | Service Layer Credits</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.Copyright">LayoutOptions.Copyright</see> Property</description>
            </item>
            <item>
              <term>Legend</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.LegendOptions">LayoutOptions.LegendOptions</see> Property</description>
            </item>
            <item>
              <term>Scale Bar</term>
              <description><see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.ScaleBarOptions">LayoutOptions.ScaleBarOptions</see> Property</description>
            </item>
            </list>
            <para>
            Note: the ArcMap <b>DataFrame</b> graphic <b>Element</b> in the <b>Layout Template</b> corresponds 
            to the <see cref="T:ESRI.ArcGIS.Client.Map">Map Control</see> and is automatically set using the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintParameters.LayoutTemplate">Printing.PrintParameters.LayoutTemplate</see> Property.
            </para>
            <para>
            It should be mentioned that there are numerous other ArcMap graphic <b>Elements</b> in a 
            <b>Layout Template</b> that can be used to create an output map via the PrintTask Class. Not all of these 
            graphic <b>Elements</b> can be controlled from the client application; they are static in nature in that 
            they are preset when the <b>Layout Template</b> is originally created and published as a PrintTask 
            ExportWebMap service via ArcGIS Server. The following ArcMap screen shot shows all of the graphic 
            <b>Elements</b> that can  be used in a <b>Layout Template</b> with those that can be controlled/adjusted 
            by the client application highlighted in red:
            </para>
            <para>
            <img border="0" alt="ArcMap Elements that can be controlled from a client application for printing via the PrintTask are highlighted in red." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.LayoutOptions_1.png"/>
            </para>
            <para>
            The default installed <b>Layout Templates</b> may be insufficient to generate maps for custom client 
            applications. Esri provides the ability to create custom <b>Layout Templates</b> with ArcMap and publish 
            them as a print service via the ExportWebMap Geoprocessing task. The ArcGIS Server manager/administrator 
            should work closely with the client application developer to achieve desired results in generating the 
            custom <b>Layout Template</b>. During this process it may be necessary to go through several iterations 
            to get the desired result. It should be noted that once a particular ExportWebMap Geoprocessing task is 
            published on ArcGIS Server, that a snapshot of the ArcMap <b>Layout Template</b> .mxd document is used 
            to generate the service. It is not possible to make a modification to the ArcMap <b>Layout Template</b> 
            .mxd document and have that change reflected in an existing ExportWebMap Geoprocessing task service. If 
            a change to the ArcMap <b>Layout Template</b> .mxd document is made, the ArcGIS Server ExportWebMap 
            Geoprocessing task service should be deleted and re-published to reflect the new changes in the 
            <b>Layout Template</b>. The 
            <see cref="P:ESRI.ArcGIS.Client.Printing.LayoutOptions.CustomTextElements">LayoutOptions.CustomTextElements</see> 
            Property document provides a code example with workflow of how to create a custom <b>Layout Template</b> 
            and publish an ArcGIS Server print task via the ExportWebMap Geoprocessing task service.
            </para>
            <para><b><u>WYSIWYG Printing of Maps</u></b></para>
            <para>
            The acronym WYSIWYG stands for "What You See Is What You Get" and is typically used to describe what 
            you view on a digital screen (i.e. desktop computer, laptop, tablet, phone, hand held device, etc.) 
            matches a hard copy print output. 
            For a typical application using a 'screen capture' type of WYSIWYG printing, the Microsoft API <a href="http://msdn.microsoft.com/en-us/library/ee671023(v=vs.95).aspx" target="_blank">Printing</a> document serves as a starting point.
            
            </para>
            <para>
            For ArcGIS developers who want to produce applications for cartographic map printing, the API's 
            provided by Microsoft may be insufficient. ESRI provides additional resources via the 
            <see cref="N:ESRI.ArcGIS.Client.Printing">ESRI.ArcGIS.Client.Printing</see> Assembly that suit 
            many of the needs for cartographic map printing via ArcGIS Server.
            </para>
            <para>
            One common request by ArcGIS developers is the ability to replicate what is seen in the Map Control 
            of an application on a printed map. In a nutshell, the key to producing a WYSIWYG printed output 
            specifically for the Map Control involves:
            </para>
            <list type="bullet">
            <item>
            <b>Knowing the Data Frame</b> - Knowing the key pieces of information on the ArcGIS Server machine 
            (specifically the <b>Data Frame</b> Height and <b>Data Frame</b> Width of the ArcMap 
            <b>Layout Template</b>).
            </item>
            <item>
            <b>Using a Ratio</b> - Ensuring that the ratio between the Height and Width of the <b>Data Frame</b> 
            in the ArcMap <b>Layout Template</b> exactly matches the ratio between the Height and Width of the 
            Map Control in the application.
            </item>
            <item>
            <b>Ensuring No Scale Dependency Layers</b> - Ensuring that any map Layers in the ArcGIS Service does 
            not use scale dependency visibility rendering (aka. no specific <b>Scale Range</b> was set in ArcMap 
            when authoring the service. Make sure that the Layer is visible for all scale levels). 
            </item>
            </list>
            <para>
            Note: An example of producing a WYSIWYG printed output specifically for the Map Control using various 
            <b>Layout Template</b> options can be found in the example code section of the 
            <see cref="T:ESRI.ArcGIS.Client.Printing.MapOptions">ESRI.ArcGIS.Client.Printing.MapOptions</see> 
            document.
            </para>
            <para>
            ArcGIS Server uses the information provided from the client application to generate the image that 
            is used for printing. There are several options available in the PrintTask.PrintParameters Class 
            which can be used in almost unlimited combinations. The key to making a successful WYSIWYG printed 
            output the Map Control, first involves understanding the constraints that ArcGIS Server has to 
            generate the map image for printing. When a specific Scale and Extent are passed to ArcGIS Server 
            from the client, the image generation process attempts to center the map based upon the Extent and 
            maintain the Scale subject to the <b>Data Frame</b> that is used for a specific 
            <b>Layout Template</b>. In most cases, the size and/or aspect ratio of the of the Map Control on 
            the client does not exactly match the <b>Data Frame</b> on the ArcGIS Server and the result is often 
            seeing more or less geographic coverage in the output image that what is in the Map Control 
            (basically the Scale of the Map Control is different than that of the <b>Data Frame</b> of the 
            <b>Layout Template</b>). Additionally when the Scale that is shown in the Map Control on the client 
            does not match that of the <b>Data Frame</b> in the <b>Layout Template</b>, Layers may or may not 
            draw based upon their scale dependency visibility setting. This may result in an output image that 
            looks very different than what is on the client. How to obtain and use each of the three key pieces 
            of information (listed previously) in order to produce a WYSIWYG printed output specifically for the 
            Map Control will be discussed in more depth as follows:
            </para>
            <para><u>Knowing the DataFrame</u></para>
            <para>
            The <b>Data Frame</b> is the placeholder for the map (and it's Layers) within the <b>Layout Template</b>. 
            In order to produce a WYSIWYG printed output specifically for the Map Control requires knowing the 
            <b>Data Frame</b> Width and Height in the <b>Layout Template</b>. Using ArcMap, open a particular 
            <b>Layout Template</b> map document (.mxd) and with the <b>Layout View</b> being active, right-click 
            on the <b>Data Frame</b> element and choose <b>Properties...</b> from the context menu (see the 
            following screen shot for opening the ‘Tabloid ANSI B Portrait.mxd’ file):
            </para>
            <para>
            <img border="0" alt="Opening the 'Tabloid ANSI B Portrait.mxd' file and choosing Properties from the context menu for the Data Frame." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_3.png"/>
            </para>
            <para>
            Then click on the <b>Size and Position</b> tab of the <b>Data Frame Properties</b> dialog to obtain 
            the <b>Width</b> and <b>Height</b> arguments (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Obtaining the Width and Height settings of the Data Frame." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_4.png"/>
            </para>
            <para><u>Using a Ratio</u></para>
            <para>
            Because the exact aspect ratio of the Map Control on the client and the <b>Data Frame</b> of the 
            <b>Layout Template</b> on ArcGIS Server will typically not match, this will result in scale 
            differences that will give non-WYSIWYG output. To correct for this, it is necessary to create 
            either <b>Height-to-Width</b> ratio or a <b>Width-to-Height</b> ratio using the results of the 
            <b>Height</b> and <b>Width</b> arguments of the <b>Data Frame</b>. This ratio will then be used 
            to adjust either the <b>Height</b> or <b>Width</b> of the Map Control in the client application 
            and thereby ensure that what geographic coverage is in the Map Control exactly matches the 
            <b>Data Frame</b> in the <b>Layout Template</b>. The following provides the generic algorithm 
            for applying the ratio (only one is needed in your application):
            </para>
            <code>
            DataFrame.Height = X (&lt;-- some static value)
            DataFrame.Width = Y (&lt;-- some static value)
            MapControl.Height = Z (&lt;-- some static value)
            MapControl.Width = MapControl.Height * (DataFrame.Width / DataFrame.Height)
            </code>
            OR
            <code>
            DataFrame.Height = X (&lt;-- some static value)
            DataFrame.Width = Y (&lt;-- some static value)
            MapControl.Width = Z (&lt;-- some static value)
            MapControl.Height = MapControl.Width * (DataFrame.Height / DataFrame.Width) 
            </code>
            <para><u>Ensuring No Scale Dependency Layers</u></para>
            <para>
            Because the physical size of the Map Control in the client application and the <b>Data Frame</b> 
            in the <b>Layout Template</b> will most likely not be exactly the same, the Scale will be different. 
            While the Extent of the geographic coverage of the Layers in between the Map Control and the 
            <b>Data Frame</b> may be the same (especially since you made sure the ratio between the two is the 
            same), because the physical size of the two elements is different the Scale will also be inherently 
            different. When Layers (or any sub-Layers) that have scale dependent visibility applied as you zoom 
            in/out, the geographic features that are displayed could change. As a safety precaution to ensure 
            WYSIWYG compliance, it is best that no scale dependency is set on any Layers that are desired to be 
            visible in the Map Control. Examining the <b>ArcGIS REST Services Directory</b> for the <b>Url</b> 
            of the web service for each Layer you can ensure that the <b>Min. Scale</b> and <b>Max. Scale</b> 
            attributes are both zero (0) (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Ensuring there are no scale dependency layers using the ArcGIS Rest Services Directory." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_5.png"/>
            </para>
            <para>
            If it turns out that non-zero value are present in the web service, it may be necessary to re-author 
            the ArcMap map document (.mxd) and re-publish the web service on ArcGIS Server. Setting the scale 
            dependency visibility in ArcMap is done in the <b>General</b> tab of the <b>Layer Properties</b> 
            dialog; look for the <b>Scale Range</b> section (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Setting the 'Show layer at all scales' radio button in the Layer Properties of an authored web service helps ensure WYSIWYG printing." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.MapOptions_6.png"/>
            </para>
            <para><b><u>Discovering PrintTask Capabilities</u></b></para>
            <para>
            It is possible to programmatically discover what capabilities are available for a particular PrintTask 
            on an ArcGIS Server service using the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">PrintTask.GetServiceInfoAsync</see> Method. 
            When the PrintTask.GetServiceInfoAsync Method is called, ArcGIS Server returns an <b>e.ServiceInfoEventArgs</b> 
            argument in the 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">PrintTask.GetServiceInfoCompleted</see> 
            Event to provide the following information:
            </para>
            <list type="table">  
            <listheader>
            <term>Argument</term>
            <description>Description</description>
            </listheader>  
            <item>
            <term>e.Error</term>
            <description>Error information (if any) for the PrintTask service.</description>
            </item>
            <item>
            <term>e.ServiceInfo</term>
            <description>
            <see cref="T:ESRI.ArcGIS.Client.Printing.PrintServiceInfo">PrintServiceInfo</see> Class that provides: return 
            image formats, Layout Templates available, and whether the service is an 'asynchronous geoprocessing task' or 
            a 'synchronous geoprocessing task'.
            </description>
            </item>
            <item>
            <term>e.UserState</term>
            <description>A userToken unique identifier to track the PrintTask.GetServiceInfoAsync Method call.</description>
            </item>
            </list>
            <para>
            Note: An example of programmatically discovering what capabilities are available for a particular PrintTask can 
            be found in the example section of the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">PrintTask.GetServiceInfoAsync</see> 
            Method documentation.
            </para>
            <para>
            The same information in the <b>e.ServiceInfo</b> argument in the previous table can also found by examining 
            the <b>ArcGIS REST Services Directory</b> for the PrintTask.Url (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="The ArcGIS Rest Services Directory can show the same information as the PrintServiceInfo Class members." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.GetServiceInfoAsync.png"/>
            </para>
            <para><b><u>Tips and Known Limitations*:</u></b></para>
            <para><u>Symbols:</u></para>
            <para>
            For triangles generated client-side in a (1) FeatureLayer or (2) <b>DynamicLayer</b> of an ArcGISDynamicMapServiceLayer, 
            the PrintTask will produce solid-fill circles as the point marker symbol. This is planned to be corrected in a 
            future version of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para>
            Custom symbols (point/line/polygon) generated client-side are 'downgraded' to simple symbols (point/line/polygon) 
            when the PrintTask is used to generate media for hardcopy printing. Additionally, simple symbols that have a 
            custom ControlTemplate applied on the client-side will also be 'downgraded' when the PrintTask is used to 
            generate media for hardcopy printing. The term 'downgraded' means that the custom symbol will be black in color 
            and be a solid-fill circle for a point, be a solid line for a line, or a solid fill for a polygon. The reason 
            for this is that ArcGIS Server uses a different graphics engine that that of the 
            ArcGIS API for Silverlight
            
            
             and is incapable of generating an exact match. 
            </para>
            <para>
            If Symbol.Color alpha values (meaning opacity) are used on the client-side as part of a ClassBreaksRenderer, the 
            PrintTask will produce a solid color for the output symbol. This is planned to be corrected in a future version 
            of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para>
            To generate correct PictureFillSymbols for use with the PrintTask, ensure that the height and width are 
            proportional to the original image.
            </para>
            <para>
            Only PictureFillSymbols that are selected on the client-side will display correctly from the PrintTask operation. 
            If the PictureFillSymbols are not selected, only the outline is displayed. This is planned to be corrected in a 
            future version of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para><u>GraphicsLayer:</u></para>
            <para>
            Client-side generated GraphicsLayers should not contain mixed geometries if using the PrintTask to generate media 
            for hard copy printing. If you need to print different geometries put each geometry type in its own GraphicsLayer. 
            For example do not use a single GraphicsLayer that has both points and polygons; separate them into a point 
            GraphicsLayer and a polygon GraphicsLayer.
            </para>
            <para><u>FeatureLayer:</u></para>
            <para>
            For client-side FeatureLayer.Geometry objects, if the FeatureLayer.Mode = SelectionOnly, the make sure and include 
            the 'ObjectID' in the FeatureLayer.Outfields, otherwise all features in the FeatureLayer will be returned in the 
            PrintTask. 
            </para>
            <para>
            Client-side FeatureLayers will only display Legend items that are viewable in the current Map Extent when the 
            PrintTask is used. Legend items are dynamically generated by the PrintTask based upon the features that are 
            currently viewable.
            </para>
            <para><u>KmlLayer:</u></para>
            <para>
            For the PrintTask, the KML specification of 2.0 and 2.1 is currently supported but the KML 2.2 specification is 
            not. This means specifically that time animation, photo overlays, and schema tags will not generate appropriate 
            output for the PrintTask. Enhanced KML support is planned to be supported in a future version of ArcGIS Server 
            and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para>
            For KML based layers, all elements are displayed via the PrintTask regardless of what is viewable in the 
            client-application. This becomes particularly apparent when the KML graphics are contained in folders. This 
            impacts the following: (1) KML folders that have graphics that are set to invisible are displayed, (2) the 
            order of layers may not be respected in generating which graphics are drawn first, (3) layers that have 
            opacity specified is not respected, and (4) labels cannot be turned off. Enhanced KML support is planned to 
            be supported in a future version of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para><u>General:</u></para>
            <para>
            Client-side generated HeatMap Layers are not generated by the PrintTask. Support for this functionality is planned 
            for a future version of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            <para>
            To show a Legend in PrintTask, layers must have the Layer.ID Property specified. The generation of a Legend is 
            supported on all Layout Template types except: MAP_ONLY. The Layout Template of MAP_ONLY only generates media 
            for hard copy printing of what is in the Map Control.
            </para>
            <para>
            Client-side generated ClassBreaksAger on temporal layers does not respect any opacity settings in the PrintTask. 
            The whole layer will have the opacity applied rather than individual graphic elements. Additionally, track lines 
            will appear on top of marker symbols in the PrintTask generated output. This is planned to be corrected in a 
            future version of ArcGIS Server and the 
            ArcGIS API for Silverlight.
            
            
            </para>
            
            <para>
            <b>*</b> The Known Limitations apply to ArcGIS Server 10.1 and 
            ArcGIS API 3.0 for Silverlight.
            
            
            </para>
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask"/> class.
            </summary>
            <param name="url">The URL of the print utilities.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelAsync">
            <summary>
            Cancels a pending asynchronous operation.
            </summary>
            <remarks>
            <para>If an operation is pending, this method calls Abort on the underlying WebRequest.</para>
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">
            <summary>
            Gets the service information <see cref="T:ESRI.ArcGIS.Client.Printing.PrintServiceInfo"/>
            Raises the <see cref="E:GetServiceInfoCompleted"/>.
            </summary>
            <param name="userToken">The user token.</param>		
            <remarks>
            <para><b><u>Discovering PrintTask Capabilities</u></b></para>
            <para>
            It is possible to programmatically discover what capabilities are available for a particular PrintTask 
            on an ArcGIS Server service using the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">PrintTask.GetServiceInfoAsync</see> Method. 
            When the PrintTask.GetServiceInfoAsync Method is called, ArcGIS Server returns an <b>e.ServiceInfoEventArgs</b> 
            argument in the 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">PrintTask.GetServiceInfoCompleted</see> 
            Event to provide the following information:
            </para>
            <list type="table">  
            <listheader>
            <term>Argument</term>
            <description>Description</description>
            </listheader>  
            <item>
            <term>e.Error</term>
            <description>Error information (if any) for the PrintTask service.</description>
            </item>
            <item>
            <term>e.ServiceInfo</term>
            <description>
            <see cref="T:ESRI.ArcGIS.Client.Printing.PrintServiceInfo">PrintServiceInfo</see> Class that provides: return 
            image formats, Layout Templates available, and whether the service is an 'asynchronous geoprocessing task' or 
            a 'synchronous geoprocessing task'.
            </description>
            </item>
            <item>
            <term>e.UserState</term>
            <description>A userToken unique identifier to track the PrintTask.GetServiceInfoAsync Method call.</description>
            </item>
            </list>
            <para>
            Note: An example of programmatically discovering what capabilities are available for a particular PrintTask can 
            be found in the example section of this document.
            </para>
            <para>
            The same information in the <b>e.ServiceInfo</b> argument in the previous table can also found by examining 
            the <b>ArcGIS REST Services Directory</b> for the PrintTask.Url (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="The ArcGIS Rest Services Directory can show the same information as the PrintServiceInfo Class members." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.GetServiceInfoAsync.png"/>
            </para>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            Supply a valid Url for a PrintTask in the TextBox and then click the 'GetServiceInfoAsync' Button. Details about 
            the PrintTask via the PrintServiceInfo Class will be returned, specifically: if there are any errors with the 
            service, whether it is an asynchronous (true) or synchronous (false) geoprocesing PrintTask, which return image 
            format types are supported, and what types of Layout Templates are supported to generate a return Map image. Note: 
            a Map Control (with Layers) is not necessary for this example since we are just trying to obtain details about the 
            PrintTask service.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Using the PrintTask.GetServiceInfoAsync Method to determine information about the PrintTask service." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintServiceInfo_1.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              
              &lt;!-- Url of the PrintTask. --&gt;
              &lt;sdk:Label Height="18" HorizontalAlignment="Left" Margin="0,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="0,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="600" FontSize="10" /&gt;
                
              &lt;!-- Button to perform the work. --&gt;
              &lt;Button Content="GetServiceInfoAsync" Height="23" Width="161" HorizontalAlignment="Left" Margin="427,91,0,0" 
                      Name="Button_GetServiceInfoAsync" VerticalAlignment="Top" Click="Button_GetServiceInfoAsync_Click" /&gt;
              
              &lt;!-- BaseEventArgs.Error messages. --&gt;
              &lt;sdk:Label Height="18" HorizontalAlignment="Left" Margin="0,157,0,0" Name="Label_BaseEventArgs_Error" 
                         Content="BaseEventArgs.Error:" VerticalAlignment="Top" Width="138" /&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="0,175,0,0" Name="TextBox_BaseEventArgs_Error" 
                       VerticalAlignment="Top" Width="600" /&gt;
              
              &lt;!--PrintServiceInfo.IsServiceAsynchronous (True = asynchronous geoprocessing task | False = synchronous geoprocessing task). --&gt;
              &lt;sdk:Label Height="18" HorizontalAlignment="Left" Margin="0,218,0,0" Name="Label_PrintServiceInfo_IsServiceAsynchronous" 
                         VerticalAlignment="Top" Width="254" Content="PrintServiceInfo.IsServiceAsynchronous:"/&gt;
              &lt;TextBox Height="30" HorizontalAlignment="Left" Margin="0,234,0,0" Name="TextBox_PrintServiceInfo_IsServiceAsynchronous" 
                       VerticalAlignment="Top" Width="600" /&gt;
              
              &lt;!-- PrintServiceInfo.Formats (for the images returned from ArcGIS Server). --&gt;
              &lt;sdk:Label Height="18" HorizontalAlignment="Left" Margin="0,282,0,0" Name="Label_PrintServiceInfo_Formats" 
                         Content="PrintServiceInfo_Formats:" VerticalAlignment="Top" Width="160" /&gt;
              &lt;TextBox Height="251" HorizontalAlignment="Left" Margin="0,302,0,0" Name="TextBox_PrintServiceInfo_Formats" 
                       VerticalAlignment="Top" Width="290" /&gt;
                
              &lt;!-- PrintServiceInfo.LayoutTemplates (the Layout Template ArcGIS Server uses to render the return image). --&gt;
              &lt;sdk:Label Height="18" HorizontalAlignment="Left" Margin="310,284,0,0" Name="Label_PrintServiceInfo_LayoutTemplates" 
                         VerticalAlignment="Top" Width="206" Content="PrintServiceInfo_LayoutTemplates:"/&gt;
              &lt;TextBox Height="251" HorizontalAlignment="Left" Margin="310,302,0,0" Name="TextBox_PrintServiceInfo_LayoutTemplates" 
                       VerticalAlignment="Top" Width="290" /&gt;
              
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="94" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="612" 
                   TextWrapping="Wrap" Text="Supply a valid Url for a PrintTask in the TextBox and then click the 
                   'GetServiceInfoAsync' Button. Details about the PrintTask via the PrintServiceInfo Class will be 
                   returned, specifically: if there are any errors with the service, whether it is an asynchronous (true) 
                   or synchronous (false) geoprocesing PrintTask, which return image format types are supported, and what 
                   types of Layout Templates are supported to generate a return Map image. Note: a Map Control (with Layers) 
                   is not necessary for this example since we are just trying to obtain details about the PrintTask service." /&gt;
            
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            
            // Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            // parts of the application.
            private ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url (either an 'asynchronous geoprocessing task' or 
              // 'synchronous geoprocessing task' will work).
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/Utilties/PrintingTools/GPServer/Export%20Web%20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Wire up an Event Handler for the PrintTask.GetServiceInfoCompleted Event.
              _PrintTask.GetServiceInfoCompleted += printTask_GetServiceInfoCompleted;
            }
            
            private void Button_GetServiceInfoAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Call the PrintTask.GetServiceInfoAsync Method to find out what the capabilities of the PrintTask are.
              _PrintTask.GetServiceInfoAsync();
            }
            
            private void printTask_GetServiceInfoCompleted(object sender, ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs e)
            {
              // Get any error information about the PrintTask.
              System.Exception theException = e.Error;
              
              if (theException != null)
              {
                // User TODO: More could be done to interrogate the Error and take appropriate action.
                TextBox_BaseEventArgs_Error.Text = theException.Message;
              }
              else
              {
                // No error occured.
                TextBox_BaseEventArgs_Error.Text = "No Exception Errors were thrown.";
              }
              
              // Get the print service information about the PrintTask.
              ESRI.ArcGIS.Client.Printing.PrintServiceInfo thePrintServiceInfo = e.ServiceInfo;
              
              if (thePrintServiceInfo != null)
              {
                // We have PrintServiceInfo results, display them.
                
                // Tell whether we have an asynchronous (true) or synchronous (false) geoprocesing PrintTask.
                bool theIsServiceAsynchronous = thePrintServiceInfo.IsServiceAsynchronous;
                TextBox_PrintServiceInfo_IsServiceAsynchronous.Text = theIsServiceAsynchronous.ToString();
                
                // Get the image formats available that can be generated on ArcGIS Server and display in a ListBox.
                System.Collections.Generic.IEnumerable&lt;string&gt; theFormats = thePrintServiceInfo.Formats;
                Text.StringBuilder sbFormats = new Text.StringBuilder();
                foreach (string theFormat in theFormats)
                {
                  sbFormats.Append(theFormat + Environment.NewLine);
                }
                TextBox_PrintServiceInfo_Formats.Text = sbFormats.ToString();
                
                // Get the Layouts availble that can be used to generate maps and display in a ListBox.
                System.Collections.Generic.IEnumerable&lt;string&gt; theLayoutTemplates = thePrintServiceInfo.LayoutTemplates;
                Text.StringBuilder sbLayoutTemplates = new Text.StringBuilder();
                foreach (string theLayoutTemplate in theLayoutTemplates)
                {
                  sbLayoutTemplates.Append(theLayoutTemplate + Environment.NewLine);
                }
                TextBox_PrintServiceInfo_LayoutTemplates.Text = sbLayoutTemplates.ToString();
              }
              else
              {
                // There is no PrintServiceInfo. Most likely we also have an e.Error as well.
                TextBox_PrintServiceInfo_Formats.Text = "No PrintServiceInfo.Formats returned.";
                TextBox_PrintServiceInfo_IsServiceAsynchronous.Text = "No PrintServiceInfo.IsServiceAsynchronous returned.";
                TextBox_PrintServiceInfo_LayoutTemplates.Text = "No PrintServiceInfo.LayoutTemplates returned.";
              }
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            ' parts of the application.
            Private _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
              
            Public Sub New()
              InitializeComponent()
              
              ' Provide a valid PrintTask.Url (either an 'asynchronous geoprocessing task' or 
              ' 'synchronous geoprocessing task' will work).
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/Utilties/PrintingTools/GPServer/Export%20Web%20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Wire up an Event Handler for the PrintTask.GetServiceInfoCompleted Event.
              AddHandler _PrintTask.GetServiceInfoCompleted, AddressOf printTask_GetServiceInfoCompleted
              
            End Sub
            
            Private Sub Button_GetServiceInfoAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Call the PrintTask.GetServiceInfoAsync Method to find out what the capabilities of the PrintTask are.
              _PrintTask.GetServiceInfoAsync()
              
            End Sub
            
            Private Sub printTask_GetServiceInfoCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs)
              
              ' Get any error information about the PrintTask.
              Dim theException As System.Exception = e.Error
              
              If theException IsNot Nothing Then
                
                ' User TODO: More could be done to interrogate the Error and take appropriate action.
                TextBox_BaseEventArgs_Error.Text = theException.Message
                
              Else
                
                ' No error occured.
                TextBox_BaseEventArgs_Error.Text = "No Exception Errors were thrown."
                
              End If
              
              ' Get the print service information about the PrintTask.
              Dim thePrintServiceInfo As ESRI.ArcGIS.Client.Printing.PrintServiceInfo = e.ServiceInfo
              
              If thePrintServiceInfo IsNot Nothing Then
                
                ' We have PrintServiceInfo results, display them.
                
                ' Tell whether we have an asynchronous (true) or synchronous (false) geoprocesing PrintTask.
                Dim theIsServiceAsynchronous As Boolean = thePrintServiceInfo.IsServiceAsynchronous
                TextBox_PrintServiceInfo_IsServiceAsynchronous.Text = theIsServiceAsynchronous.ToString
                
                ' Get the image formats availble that can be generated on ArcGIS Server and display in a ListBox.
                Dim theFormats As System.Collections.Generic.IEnumerable(Of String) = thePrintServiceInfo.Formats
                Dim sbFormats As New Text.StringBuilder
                For Each theFormat As String In theFormats
                  sbFormats.Append(theFormat + vbCrLf)
                Next
                TextBox_PrintServiceInfo_Formats.Text = sbFormats.ToString
                
                ' Get the Layouts available that can be used to generate maps and display in a ListBox.
                Dim theLayoutTemplates As System.Collections.Generic.IEnumerable(Of String) = thePrintServiceInfo.LayoutTemplates
                Dim sbLayoutTemplates As New Text.StringBuilder
                For Each theLayoutTemplate As String In theLayoutTemplates
                  sbLayoutTemplates.Append(theLayoutTemplate + vbCrLf)
                Next
                TextBox_PrintServiceInfo_LayoutTemplates.Text = sbLayoutTemplates.ToString
                
              Else
                
                ' There is no PrintServiceInfo. Most likely we also have an e.Error as well.
                TextBox_PrintServiceInfo_Formats.Text = "No PrintServiceInfo.Formats returned."
                TextBox_PrintServiceInfo_IsServiceAsynchronous.Text = "No PrintServiceInfo.IsServiceAsynchronous returned."
                TextBox_PrintServiceInfo_LayoutTemplates.Text = "No PrintServiceInfo.LayoutTemplates returned."
                
              End If
              
            End Sub
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">
            <summary>
            Executes print, a server-synchronous operation.
            Raises the <see cref="E:ExecuteCompleted"/>.
            </summary>
            <param name="printParameters">The print parameters.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">
            <summary>
            Executes print, a server-synchronous operation.
            Raises the <see cref="E:ExecuteCompleted"/>.
            </summary>
            <param name="printParameters">The print parameters.</param>
            <param name="userToken">The user token.</param>
            <remarks>
            <para><b><u>Synchronous -vs- Asynchronous Geoprocessing Tasks</u></b></para>
            <para>
            When it comes to using the PrintTask in web development using the 
            ArcGIS API for Silverlight
            
            
             to generate an image on ArcGIS Server, as a developer you have two options: <b>synchronous geoprocessing tasks</b> 
            and <b>asynchronous geoprocessing tasks</b>. In a traditional sense the terms "synchronous" means that your 
            computer will wait while a process executes on the server and "asynchronous" means that your computer does 
            not have to wait for the process to finish execution and you can move on to other operations. However in 
            web development using 
            Silverlight,
            
            
             all web requests are asynchronous in nature, meaning 
            that once a web request has initiated you are free to perform other operations/functionality in your 
            application as it remains highly responsive. When it comes to the PrintTask there are some important
            differences between the <b>synchronous geoprocessing tasks</b> and <b>asynchronous geoprocessing tasks</b> 
            that are outlined as follows:
            </para>
            <list type="bullet">
            <item>
            A <b>synchronous geoprocessing task</b> means that once ArcGIS Server starts the task to generate the image, 
            ArcGIS Server is dedicated to that operation until it completes. It should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>synchronous geoprocessing task</b> 
            has been initiated you are still free to perform other operations as the application remains highly responsive. 
            See the code example in this document for how a <b>synchronous geoprocessing task</b> works.  
            </item>
            <item>
            An <b>asynchronous geoprocessing task</b> means that ArcGIS Server will control when it can handle generating 
            an image based upon its computing load and will multi-task multiple operations simultaneously until the 
            operation is complete. Again it should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>asynchronous geoprocessing task</b> has been initiated you are 
            still free to perform other operations as the application remains highly responsive. See the code example in the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.SubmitJobAsync</see> Method 
            Method for how an <b>asynchronous geoprocessing task</b> works.
            </item>
            </list>
            <para>
            When constructing a PrintTask the following Types are used by both the <b>synchronous geoprocessing tasks</b> 
            or <b>asynchronous geoprocessing tasks</b>: 
            </para>
            <list type="bullet">
            <item>
            <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask">PrintTask</see> Constructor
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.DisableClientCaching">DisableClientCaching</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.ProxyURL">ProxyURL</see> Property</item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Token">Token</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">Url</see> Property
            </item>
            </list>
            <para>
            The following table illustrates which PrintTask Types are dedicated exclusively to a 
            <b>synchronous geoprocessing task</b> or an <b>asynchronous geoprocessing task</b>:
            </para>
            <list type="table">  
            <listheader>
            <term1>Synchronous geoprocessing task</term1>
            <term2>Asynchronous geoprocessing task</term2>
            </listheader>  
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelAsync">CancelAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobAsync(System.String)">CancelJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">ExecuteAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobStatusUpdates(System.String)">CancelJobStatusUpdates</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">GetServiceInfoAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">SubmitJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">IsBusy</see> Property</term1>
            <term2><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.UpdateDelay">UpdateDelay</see> Property</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteCompleted">ExecuteCompleted</see> Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">StatusUpdated</see> Event</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">GetServiceInfoCompleted</see>Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted">JobCompleted</see> Event</term2>
            </item>
            </list>
            <para>
            As a developer of a web based 
            Silverlight
            
            
             application, when choosing whether to perform a 
            PrintTask based upon the methodology of <b>synchronous geoprocessing task</b> or an 
            <b>asynchronous geoprocessing task</b>, the following information may be helpful in the decision making process:
            </para>
            <list type="bullet">
            <item>
            <para>
            By default, a <b>synchronous geoprocessing task</b> is created when ArcGIS Server is installed and initially 
            configured. This means that no other work is required on ArcGIS Server to enable using the PrintTask (other 
            than starting the <b>PrintingTools</b>, <b>Geoprocessing Service</b>) by an ArcGIS 
            Silverlight
            
            
             application developer. Typically in ArcGIS Server, this 
            <b>synchronous geoprocessing task</b> is located under in the <b>ArcGIS REST Services Directory</b> in the 
            <b>Utilities</b> folder as an <b>Utilties/ExportWebMap (GPServer)</b> Service. The Task is usually called 
            <b>Export Web Map Task</b> and has an <b>Execution Type</b> of <b>esriExecutionTypeSynchronous</b>. For 
            example, assume for the sample ESRI ArcGIS Server (http://servicesbeta2.esri.com/arcgis/rest/) the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">PrintTask.Url</see> for the 
            <b>synchronous geoprocessing task</b> would be as follows (see the following screen shot):
            </para>
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of the default Export Web Map Task in Synchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeSynchronous.png"/>
            </para>
            </item>
            <item>
            <para>
            For small PrintTask operations using a <b>synchronous geoprocessing task</b> will probably yield faster 
            results in generating a return image/pdf.
            </para>
            </item>
            <item>
            <para>
            A web based 
            Silverlight
            
            
             application can only issue one PrintTask via a 
            <b>synchronous geoprocessing task</b> at a time. This means that it is not possible to have multiple 
            PrintTask operations (i.e. generating multiple image/.pdf files at a time) using a 
            <b>synchronous geoprocessing task</b>. Use the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">PrintTask.IsBusy</see> Property to determine if 
            an existing <b>synchronous geoprocessing task</b> is running before issuing the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">PrintTask.ExecuteAsync</see> 
            Method to avoid the Visual Studio runtime error: <b>NotSupportedException was unhandled by user code</b> 
            ("Task does not support concurrent I/O operations. Cancel the pending request or wait for it to complete"). 
            </para>
            </item>
            <item>
            <para>
            If multiple simultaneous PrintTask operations are necessary from a single web based 
            Silverlight
            
            
             application (i.e. an application that produces numerous images/.pdf for cartographic production), then 
            use the <b>asynchronous geoprocessing task</b> options for better performance.
            </para>
            </item>
            <item>
            <para>
            If the PrintTask operations will be used for very large image/.pdf generation or numerous ArcGIS 
            Silverlight
            
            
             applications will be utilizing a single ArcGIS Server and thereby causing 
            internet browser time-out error messages, then an <b>asynchronous geoprocessing task</b> may be the better 
            choice. It may be possible to increase the amount of time an internet browser waits before a time-out error 
            message occurs when using a <b>synchronous geoprocessing task</b> but this will require testing to 
            determine which option is best for your organization.
            </para>
            </item>
            <item>
            <para>
            Using an <b>asynchronous geoprocessing task</b> requires configuring an ArcGIS Server Geoprocessing Task. 
            This is not done automatically as part of the ArcGIS Server installation/configuration. One option is to use
            ArcMap to run the ArcToolbox: <b>Server Tools</b> | <b>Printing</b> | <b>Export Web Map</b> tool and when 
            the Results are completed right click on the <b>ExportWebMap</b> session and <b>Share As</b> a 
            <b>Geoprocessing Service</b> that can be used by ArcGIS Server. Another option is to use the default 
            ArcGIS Server: <b>Printing Tools</b>, <b>Geoprocessing Service</b> (located in the Utilities folder) that is 
            created when ArcGIS Server is initially installed/configured and change its <b>Execution Mode</b> from Synchronous to 
            Asynchronous (see the following screen shot for an example test ArcGIS Server running on the local 
            developement computer) and re-starting the service: <br/>
            </para>
            <para>
            <img border="0" alt="Using ArcGIS Server Manager to change the Execution Mode of an Export Web Map Task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_ArcGISServerManager_ExecutionMode.png"/>
            </para>
            <para>
            This will result in an <b>ArcGIS REST Services Directory</b> page that looks similar to the following 
            screen shot:
            </para>
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of an Export Web Map Task in Asynchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeAsynchronous.png"/>
            </para>
            </item>
            <item>
            <para> 
            Using the PrintTask via <b>asynchronous geoprocessing task</b> Types provide much better options to 
            track the status of image/.pdf creation. The 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">PrintTask.StatusUpdated</see> Event uses 
            the <see cref="T:ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs">ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs</see> 
            Class to give instant status information of the operation.
            </para>
            </item>
            </list>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            When the application loads, enter a correct Url to an ArcGIS Server PrintTask based on a 'synchronous 
            geoprocessing task'. Then click the 'ExecuteAsync' button to generate a .JPG image returned in an 
            internet browser. Status informatonal messages will display to provide information on the PrintTask 
            operation. Experiment by clicking the 'ExecuteAsync' button in rapid succession (ie. before the 
            PrintTask has a chance to complete generating an image/.pdf file to better understand how a 'synchronous 
            geoprocesing task' works.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Demonstrating how to use the PrintTask.ExecuteAsync Method for an synchronous geoprocessing task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.ExecuteAsync_1.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="12,261,0,0" 
                        Name="MyMap" VerticalAlignment="Top" WrapAround="True" Height="300" Width="600"
                         Extent="-10929488.234,4525208.388,-10906776.553,4535252.104"&gt;
                &lt;esri:Map.Layers&gt;
                  &lt;esri:LayerCollection&gt;
                  
                    &lt;!-- Add some layers to the Map Control. --&gt;
                    &lt;esri:ArcGISTiledMapServiceLayer 
                      Url="http://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer" /&gt;
                    &lt;esri:FeatureLayer Mode="OnDemand" DisableClientCaching="True" 
                      Url="http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Petroleum/KSWells/MapServer/0" /&gt;
                    
                  &lt;/esri:LayerCollection&gt;
                &lt;/esri:Map.Layers&gt;
              &lt;/esri:Map&gt;
              
              &lt;!-- Url --&gt;
              &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="605" FontSize="10" /&gt;
              
              &lt;!-- Buttons to perform the work. --&gt;
              &lt;Button Content="ExecuteAsync" Height="39" Width="201" HorizontalAlignment="Left" Margin="12,147,0,0" 
                      Name="Button_ExecuteAsync" VerticalAlignment="Top" Click="Button_ExecuteAsync_Click" IsEnabled="True"/&gt;
              &lt;Button Content="CancelAsync" Height="35" Width="201" HorizontalAlignment="Left" Margin="12,192,0,0" 
                      Name="Button_CancelAsync" VerticalAlignment="Top" Click="Button_CancelAsync_Click" IsEnabled="False"/&gt;
              
              &lt;!-- Provide PrintTask information messages. --&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="229,147,0,0" Name="Label_StatusInfo" 
                         VerticalAlignment="Top" Width="120" Content="Status Information:"/&gt;
              &lt;ListBox Height="64" HorizontalAlignment="Left" Margin="229,163,0,0" Name="ListBox_StatusInformation" 
                       VerticalAlignment="Top" Width="383" /&gt;
              
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="94" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="625" 
                 TextWrapping="Wrap" Text="When the application loads, enter a correct Url to an ArcGIS Server PrintTask 
                  based on a 'synchronous geoprocessing task'. Then click the 'ExecuteAsync' button to generate a
                  .JPG image returned in an internet browser. Status informatonal messages will display to provide 
                  information on the PrintTask operation. Experiment by clicking the 'ExecuteAsync' button in rapid 
                  succession (ie. before the PrintTask has a chance to complete generating an image/.pdf file to better 
                  understand how a 'synchronous geoprocesing task' works." /&gt;
                
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            // Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            // parts of the application.
            private ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = true;
              
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              _PrintTask.ExecuteCompleted += printTask_ExecuteCompleted;
            }
            
            private void Button_ExecuteAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              // Define the ExportOptions.
              ESRI.ArcGIS.Client.Printing.ExportOptions myExportOptions = new ESRI.ArcGIS.Client.Printing.ExportOptions();
              myExportOptions.Dpi = 96; //96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = new Size(MyMap.ActualWidth, MyMap.ActualHeight); // Use the dimensions of the Map
              
              // Define the PrintParameters.
              ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
              myPrintParameters.ExportOptions = myExportOptions; // Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY"; // Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "JPG"; // Look to the REST service to see what image formats are supported.
              
              // NOTE: 
              // If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              // using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              // NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              // the pending request or wait for it to complete." 
              // In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              if (_PrintTask.IsBusy == true)
              {
                // There is an existing 'synchronous geoprocessing task' PrintTask running. 
                
                // Use a simple MessageBox to get user direction on whether to stay with the currently running 'synchronous 
                // geoprocessing task' PrintTask or cancel it and start another one.
                System.Windows.MessageBoxResult myMessage = MessageBox.Show("Click 'Cancel' to kill the prior print job and print this one OR click 'OK' to finish the prior " + "print job and wait to re-click the Print button.", "Action Required", MessageBoxButton.OKCancel);
                
                if (myMessage == MessageBoxResult.Cancel)
                {
                  // The user has opted to cancel the currently runnning 'synchronous geoprocessing task' PrintTask. 
                  
                  // Kill the PrintTask.
                  _PrintTask.CancelAsync();
                  
                  // Clear out the status informational messages. 
                  ListBox_StatusInformation.Items.Clear();
                  
                  // Create a UserToken to identify which PrintTask is running.
                  string myToken = "MY TOKEN2";
                  
                  // Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                  _PrintTask.ExecuteAsync(myPrintParameters, myToken);
                  
                  // Update the status informational messages.
                  ListBox_StatusInformation.Items.Add("The PrintTask was started.");
                }
                else if (myMessage == MessageBoxResult.OK)
                {
                  // The user has opted to let the currently runnning 'synchronous geoprocessing task' PrintTask complete. 
                  
                  // Update the status informational messages.
                  ListBox_StatusInformation.Items.Add("The PrintTask is busy (still processing).");
                }
              }
              else if (_PrintTask.IsBusy == false)
              {
                // There is not and existing 'synchronous geoprocessing task' PrintTask running.
                
                // Clear out the status informational messages. 
                ListBox_StatusInformation.Items.Clear();
                
                // Create a UserToken to identify which PrintTask is running.
                string myToken = "MY TOKEN";
                
                // Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                _PrintTask.ExecuteAsync(myPrintParameters, myToken);
                
                // Enable button for the user to cancel the PrintTask request.
                Button_CancelAsync.IsEnabled = true;
                
                // Update the status informational messages.
                ListBox_StatusInformation.Items.Add("The PrintTask was started.");
              }
            }
            
            private void printTask_ExecuteCompleted(object sender, ESRI.ArcGIS.Client.Printing.PrintEventArgs e)
            {
              // Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              // Get any error information (add your own enhancements if desired). 
              System.Exception mySystemException = e.Error;
              
              // Get the PrintResult from the completed operation.
              ESRI.ArcGIS.Client.Printing.PrintResult myPrintResult = e.PrintResult;
              
              // Test is we have valid return PrintResults.
              if (myPrintResult != null)
              {
                // Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                List&lt;ESRI.ArcGIS.Client.Tasks.GPMessage&gt; myListOfGPMessage = myPrintResult.Messages;
                
                // This is the userToken Parameter of the ExecuteAsync(printParameters,userToken)
                object myUserState = e.UserState;
                
                // Update the status informational messages.
                ListBox_StatusInformation.Items.Add("The PrintTask was completed for: " + myUserState.ToString());
                
                // Get the location of the image/.pdf created by ArcGIS Server.
                System.Uri myUri = myPrintResult.Url;
                
                // Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank");
              }
            }
            
            private void Button_CancelAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // This will cancel the ExecuteAsync operation. 
              _PrintTask.CancelAsync();
              
              // Update the status informational messages.
              ListBox_StatusInformation.Items.Add("The PrintTask was canceled.");
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            ' parts of the application.
            Private _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
            
            Public Sub New()
              
              InitializeComponent()
              
              ' Provide a valid PrintTask.Url for a "synchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = True
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the PrintTask.ExecuteCompleted Event.
              AddHandler _PrintTask.ExecuteCompleted, AddressOf printTask_ExecuteCompleted
              
            End Sub
            
            Private Sub Button_ExecuteAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              ' Define the ExportOptions.
              Dim myExportOptions As New ESRI.ArcGIS.Client.Printing.ExportOptions
              myExportOptions.Dpi = 96 '96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = New Size(MyMap.ActualWidth, MyMap.ActualHeight) ' Use the dimensions of the Map
              
              ' Define the PrintParameters.
              Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
              myPrintParameters.ExportOptions = myExportOptions ' Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY" ' Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "JPG" ' Look to the REST service to see what image formats are supported.
              
              ' NOTE: 
              ' If you try to submit more that one 'synchronous geoprocessing task' via PrintTask.ExecuteAsync at a time 
              ' using the ExecuteAsync methadology you will get a Visual Studio (Runtime) error: 
              ' NotSupportedException was unhandled by user code. "Task does not support concurrent  I/O operations. Cancel 
              ' the pending request or wait for it to complete." 
              ' In order to overcome this, use the PrintTask.IsBusy Property and take action accordingly.
              
              If _PrintTask.IsBusy = True Then
                
                ' There is an existing 'synchronous geoprocessing task' PrintTask running. 
                
                ' Use a simple MessageBox to get user direction on whether to stay with the currently running 'synchronous 
                ' geoprocessing task' PrintTask or cancel it and start another one.
                Dim myMessage As System.Windows.MessageBoxResult =
                 MessageBox.Show("Click 'Cancel' to kill the prior print job and print this one OR click 'OK' to finish the prior " +
                                 "print job and wait to re-click the Print button.", "Action Required", MessageBoxButton.OKCancel)
                
                If myMessage = MessageBoxResult.Cancel Then
                  
                  ' The user has opted to cancel the currently runnning 'synchronous geoprocessing task' PrintTask. 
                  
                  ' Kill the PrintTask.
                  _PrintTask.CancelAsync()
                  
                  ' Clear out the status informational messages. 
                  ListBox_StatusInformation.Items.Clear()
                  
                  ' Create a UserToken to identify which PrintTask is running.
                  Dim myToken As String = "MY TOKEN2"
                  
                  ' Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                  _PrintTask.ExecuteAsync(myPrintParameters, myToken)
                  
                  ' Update the status informational messages.
                  ListBox_StatusInformation.Items.Add("The PrintTask was started.")
                  
                ElseIf myMessage = MessageBoxResult.OK Then
                  
                  ' The user has opted to let the currently runnning 'synchronous geoprocessing task' PrintTask complete. 
                  
                  ' Update the status informational messages.
                  ListBox_StatusInformation.Items.Add("The PrintTask is busy (still processing).")
                  
                End If
                  
              ElseIf _PrintTask.IsBusy = False Then
                 
                ' There is not and existing 'synchronous geoprocessing task' PrintTask running.
                
                ' Clear out the status informational messages. 
                ListBox_StatusInformation.Items.Clear()
                
                ' Create a UserToken to identify which PrintTask is running.
                Dim myToken As String = "MY TOKEN"
                
                ' Use the 'synchronous geoprocessing task' PrintTask.ExecuteAsync Method.
                _PrintTask.ExecuteAsync(myPrintParameters, myToken)
                
                ' Enable button for the user to cancel the PrintTask request.
                Button_CancelAsync.IsEnabled = True
                
                ' Update the status informational messages.
                ListBox_StatusInformation.Items.Add("The PrintTask was started.")
                
              End If
                
            End Sub
              
            Private Sub printTask_ExecuteCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.PrintEventArgs)
              
              ' Use only for ExecuteAsync operations (i.e. synchronous geoprocessing tasks).
              
              ' Get any error information (add your own enhancements if desired). 
              Dim mySystemException As System.Exception = e.Error
              
              ' Get the PrintResult from the completed operation.
              Dim myPrintResult As ESRI.ArcGIS.Client.Printing.PrintResult = e.PrintResult
              
              ' Test is we have valid return PrintResults.
              If myPrintResult IsNot Nothing Then
                
                ' Get any messages returned from ArcGIS Server (add your own enhancements if desired).
                Dim myListOfGPMessage As List(Of ESRI.ArcGIS.Client.Tasks.GPMessage) = myPrintResult.Messages
                
                ' This is the userToken Parameter of the ExecuteAsync(printParameters,userToken)
                Dim myUserState As Object = e.UserState
                
                ' Update the status informational messages.
                ListBox_StatusInformation.Items.Add("The PrintTask was completed for: " + myUserState)
                
                ' Get the location of the image/.pdf created by ArcGIS Server.
                Dim myUri As System.Uri = myPrintResult.Url
                
                ' Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank")
                
              End If
                
            End Sub
            
            Private Sub Button_CancelAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' This will cancel the ExecuteAsync operation. 
              _PrintTask.CancelAsync()
              
              ' Update the status informational messages.
              ListBox_StatusInformation.Items.Add("The PrintTask was canceled.")
            
            End Sub
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">
            <summary>
            Submits a print job request to the server to execute an asynchronous geoprocessing task.
            Raises the <see cref="e:StatusUpdated"/> and <see cref="e:JobCompleted"/>.
            </summary>
            <param name="printParameters">The print parameters.</param>
            <param name="userToken">The user token.</param>
            <remarks>
            <para><b><u>Synchronous -vs- Asynchronous Geoprocessing Tasks</u></b></para>
            <para>
            When it comes to using the PrintTask in web development using the 
            ArcGIS API for Silverlight
            
            
             to generate an image on ArcGIS Server, as a developer you have two options: <b>synchronous geoprocessing tasks</b> 
            and <b>asynchronous geoprocessing tasks</b>. In a traditional sense the terms "synchronous" means that your 
            computer will wait while a process executes on the server and "asynchronous" means that your computer does 
            not have to wait for the process to finish execution and you can move on to other operations. However in 
            web development using the 
            ArcGIS API for Silverlight,
            
            
             all web requests are asynchronous in nature, meaning 
            that once a web request has initiated you are free to perform other operations/functionality in your 
            application as it remains highly responsive. When it comes to the PrintTask there are some important
            differences between the <b>synchronous geoprocessing tasks</b> and <b>asynchronous geoprocessing tasks</b> 
            that are outlined as follows:
            </para>
            <list type="bullet">
            <item>
            A <b>synchronous geoprocessing task</b> means that once ArcGIS Server starts the task to generate the image, 
            ArcGIS Server is dedicated to that operation until it completes. It should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>synchronous geoprocessing task</b> 
            has been initiated you are still free to perform other operations as the application remains highly responsive. 
            See the code example in the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">PrintTask.ExecuteAsync(PrintParameters,Object)</see> 
            Method for how a <b>synchronous geoprocessing task</b> works.
            </item>
            <item>
            An <b>asynchronous geoprocessing task</b> means that ArcGIS Server will control when it can handle generating 
            an image based upon its computing load and will multi-task multiple operations simultaneously until the 
            operation is complete. Again it should be noted that from the web based 
            Silverlight
            
            
             application’s perspective, that once the <b>asynchronous geoprocessing task</b> has been initiated you are 
            still free to perform other operations as the application remains highly responsive. See the code example in 
            this document for how an <b>asynchronous geoprocessing task</b> works.
            </item>
            </list>
            <para>
            When constructing a PrintTask the following Types are used by both the <b>synchronous geoprocessing tasks</b> 
            or <b>asynchronous geoprocessing tasks</b>: 
            </para>
            <list type="bullet">
            <item>
            <see cref="T:ESRI.ArcGIS.Client.Printing.PrintTask">PrintTask</see> Constructor
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.DisableClientCaching">DisableClientCaching</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.ProxyURL">ProxyURL</see> Property</item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Token">Token</see> Property
            </item>
            <item>
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">Url</see> Property
            </item>
            </list>
            <para>
            The following table illustrates which PrintTask Types are dedicated exclusively to a 
            <b>synchronous geoprocessing task</b> or an <b>asynchronous geoprocessing task</b>:
            </para>
            <list type="table">  
            <listheader>
            <term1>Synchronous geoprocessing task</term1>
            <term2>Asynchronous geoprocessing task</term2>
            </listheader>  
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelAsync">CancelAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobAsync(System.String)">CancelJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">ExecuteAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobStatusUpdates(System.String)">CancelJobStatusUpdates</see> Method</term2>
            </item>
            <item>
            <term1><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoAsync(System.Object)">GetServiceInfoAsync</see> Method</term1>
            <term2><see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)">SubmitJobAsync</see> Method</term2>
            </item>
            <item>
            <term1><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">IsBusy</see> Property</term1>
            <term2><see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.UpdateDelay">UpdateDelay</see> Property</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteCompleted">ExecuteCompleted</see> Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">StatusUpdated</see> Event</term2>
            </item>
            <item>
            <term1><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">GetServiceInfoCompleted</see>Event</term1>
            <term2><see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted">JobCompleted</see> Event</term2>
            </item>
            </list>
            <para>
            As a developer of a web based 
            Silverlight
            
            
             application, when choosing whether to perform a 
            PrintTask based upon the methodology of <b>synchronous geoprocessing task</b> or an 
            <b>asynchronous geoprocessing task</b>, the following information may be helpful in the decision making process:
            </para>
            <list type="bullet">
            <item>
            <para>
            By default, a <b>synchronous geoprocessing task</b> is created when ArcGIS Server is installed and initially 
            configured. This means that no other work is required on ArcGIS Server to enable using the PrintTask (other 
            than starting the <b>PrintingTools</b>, <b>Geoprocessing Service</b>) by an 
            Silverlight
            
            
             application developer. Typically in ArcGIS Server, this 
            <b>synchronous geoprocessing task</b> is located under in the <b>ArcGIS REST Services Directory</b> in the 
            <b>Utilities</b> folder as an <b>Utilties/ExportWebMap (GPServer)</b> Service. The Task is usually called 
            <b>Export Web Map Task</b> and has an <b>Execution Type</b> of <b>esriExecutionTypeSynchronous</b>. For 
            example, assume for the sample ESRI ArcGIS Server (http://servicesbeta2.esri.com/arcgis/rest/) the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">PrintTask.Url</see> for the 
            <b>synchronous geoprocessing task</b> would be as follows (see the following screen shot): 
            </para>
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of the default Export Web Map Task in Synchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeSynchronous.png"/>
            </para>
            </item>
            <item>
            <para>
            For small PrintTask operations using a <b>synchronous geoprocessing task</b> will probably yield faster 
            results in generating a return image/pdf.
            </para>
            </item>
            <item>
            <para>
            A web based 
            Silverlight
            
            
             application can only issue one PrintTask via a 
            <b>synchronous geoprocessing task</b> at a time. This means that it is not possible to have multiple 
            PrintTask operations (i.e. generating multiple image/.pdf files at a time) using a 
            <b>synchronous geoprocessing task</b>. Use the 
            <see cref="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">PrintTask.IsBusy</see> Property to determine if 
            an existing <b>synchronous geoprocessing task</b> is running before issuing the 
            <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteAsync(ESRI.ArcGIS.Client.Printing.PrintParameters)">PrintTask.ExecuteAsync</see> 
            Method to avoid the Visual Studio runtime error: <b>NotSupportedException was unhandled by user code</b> 
            ("Task does not support concurrent I/O operations. Cancel the pending request or wait for it to complete"). 
            </para>
            </item>
            <item>
            <para>
            If multiple simultaneous PrintTask operations are necessary from a single web based 
            Silverlight
            
            
             application (i.e. an application that produces numerous images/.pdf for cartographic production), then 
            use the <b>asynchronous geoprocessing task</b> options for better performance.
            </para>
            </item>
            <item>
            <para>
            If the PrintTask operations will be used for very large image/.pdf generation or numerous ArcGIS 
            Silverlight
            
            
             applications will be utilizing a single ArcGIS Server and thereby causing 
            internet browser time-out error messages, then an <b>asynchronous geoprocessing task</b> may be the better 
            choice. It may be possible to increase the amount of time an internet browser waits before a time-out error 
            message occurs when using a <b>synchronous geoprocessing task</b> but this will require testing to 
            determine which option is best for your organization.
            </para>
            </item>
            <item>
            <para>
            Using an <b>asynchronous geoprocessing task</b> requires configuring an ArcGIS Server Geoprocessing Task. 
            This is not done automatically as part of the ArcGIS Server installation/configuration. One option is to use
            ArcMap to run the ArcToolbox: <b>Server Tools</b> | <b>Printing</b> | <b>Export Web Map</b> tool and when 
            the Results are completed right click on the <b>ExportWebMap</b> session and <b>Share As</b> a 
            <b>Geoprocessing Service</b> that can be used by ArcGIS Server. Another option is to use the default 
            ArcGIS Server: <b>Printing Tools</b>, <b>Geoprocessing Service</b> (located in the Utilities folder) that is 
            created when ArcGIS Server is initially installed/configured and change its <b>Execution Mode</b> from Synchronous to 
            Asynchronous (see the following screen shot for an example test ArcGIS Server running on the local 
            developement computer) and re-starting the service: 
            </para>
            <para>
            <img border="0" alt="Using ArcGIS Server Manager to change the Execution Mode of an Export Web Map Task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_ArcGISServerManager_ExecutionMode.png"/>
            </para> This will result in an <b>ArcGIS REST Services Directory</b> page that looks similar to the following 
            screen shot:
            <para>
            <img border="0" alt="Looking at the ArcGIS REST Services Directory of an Export Web Map Task in Asynchronous mode." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask_esriExecutionTypeAsynchronous.png"/>
            </para>
            </item>
            <item>
            <para>
            Using the PrintTask via <b>asynchronous geoprocessing task</b> Types provide much better options to 
            track the status of image/.pdf creation. The 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">PrintTask.StatusUpdated</see> Event uses 
            the <see cref="T:ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs">ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs</see> 
            Class to give instant status information of the operation.
            </para>
            </item>
            </list>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            When the application loads, enter a correct Url to an ArcGIS Server PrintTask based on an 'asynchronous 
            geoprocessing task'. Then click the 'SubmitJobAsync' button to generate a .JPG image returned in an 
            internet browser. JobInfo messages will display to provide status information on the PrintTask operation. 
            Experiment by changing the 'UpdateDelay' setting as well as clicking the 'CancelJobAsync' button to see 
            their effect on the PrintTask operation.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Demonstrating how to use the PrintTask.SubmitJobAsync Method for an asynchronous geoprocessing task." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.SubmitJobAsync_1.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="12,261,0,0" 
                        Name="MyMap" VerticalAlignment="Top" WrapAround="True" Height="300" Width="600"
                         Extent="-10929488.234,4525208.388,-10906776.553,4535252.104"&gt;
                &lt;esri:Map.Layers&gt;
                  &lt;esri:LayerCollection&gt;
                              
                    &lt;!-- Add some layers to the Map Control. --&gt;
                    &lt;esri:ArcGISTiledMapServiceLayer 
                      Url="http://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer" /&gt;
                    &lt;esri:ArcGISDynamicMapServiceLayer 
                      Url="http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Petroleum/KSFields/MapServer" /&gt;
                    &lt;esri:FeatureLayer Mode="OnDemand" DisableClientCaching="True" 
                      Url="http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Petroleum/KSWells/MapServer/0" /&gt;
                      
                  &lt;/esri:LayerCollection&gt;
                &lt;/esri:Map.Layers&gt;
              &lt;/esri:Map&gt;
                  
              &lt;!-- Url --&gt;
              &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="605" FontSize="10" /&gt;
              
              &lt;!-- UpdateDelay --&gt;
              &lt;sdk:Label Height="19" HorizontalAlignment="Left" Margin="14,156,0,0" Name="Label1" VerticalAlignment="Top" 
                         Width="80"  Content="UpdateDelay:" /&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="14,174,0,0" Name="TextBox_UpdateDelay" 
                       VerticalAlignment="Top" Width="80" Text="1000"/&gt;
              
              &lt;!-- Buttons to perform the work. --&gt;
              &lt;Button Content="SubmitJobAsync" Height="23" Width="201" HorizontalAlignment="Left" Margin="110,144,0,0" 
                      Name="Button_SubmitJobAsync" VerticalAlignment="Top" Click="Button_SubmitJobAsync_Click" IsEnabled="True"/&gt;
              &lt;Button Content="CancelJobAsync" Height="23" Width="201" HorizontalAlignment="Left" Margin="110,173,0,0" 
                      Name="Button_CancelJobAsync" VerticalAlignment="Top" Click="Button_CancelJobAsync_Click" IsEnabled="False"/&gt;
              
              &lt;!-- JobInfo --&gt;
              &lt;sdk:Label Height="16" HorizontalAlignment="Left" Margin="341,147,0,0" Name="Label_JobId" VerticalAlignment="Top" 
                         Width="35" Content="JobId:"/&gt;
              &lt;TextBlock Height="16" HorizontalAlignment="Left" Margin="382,147,0,0" Name="TextBlock_JobId" 
                         VerticalAlignment="Top" Width="231" /&gt;
              &lt;sdk:Label Height="15" Margin="317,169,0,0" Name="Label_JobStatus" VerticalAlignment="Top" Content="JobStatus:" 
                         HorizontalAlignment="Left" Width="65" /&gt;
              &lt;TextBlock Height="15" Margin="382,169,12,0" Name="TextBlock_JobStatus" VerticalAlignment="Top" /&gt;
              &lt;sdk:Label Height="23" HorizontalAlignment="Left" Margin="317,192,0,0" Name="Label_Messages" VerticalAlignment="Top" 
                         Width="65" Content="Messages:"/&gt;
              &lt;ListBox Height="64" HorizontalAlignment="Left" Margin="382,192,0,0" Name="ListBox_Messages" VerticalAlignment="Top" 
                       Width="231" /&gt;
                
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="91" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="790" 
                 TextWrapping="Wrap" Text="When the application loads, enter a correct Url to an ArcGIS Server PrintTask 
                  based on an 'asynchronous geoprocessing task'. Then click the 'SubmitJobAsync' button to generate a
                  .JPG image returned in an internet browser. JobInfo messages will display to provide status information 
                  on the PrintTask operation. Experiment by changing the 'UpdateDelay' setting as well as clicking the
                  'CancelJobAsync' button to see their effect on the PrintTask operation." /&gt;
              
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            // Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            // parts of the application.
            private ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url for a "asynchronous geoprocessing task".
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = true;
              
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the PrintTask.StatusUpdated Event.
              _PrintTask.StatusUpdated += printTask_StatusUpdated;
              
              // Wire up an Event Handler for the PrintTask.JobCompleted Event.
              _PrintTask.JobCompleted += printTask_JobCompleted;
            }
            
            private void Button_SubmitJobAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              // Define the ExportOptions.
              ESRI.ArcGIS.Client.Printing.ExportOptions myExportOptions = new ESRI.ArcGIS.Client.Printing.ExportOptions();
              myExportOptions.Dpi = 96; //96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = new Size(MyMap.ActualWidth, MyMap.ActualHeight); // Use the dimensions of the Map
              
              // Define the PrintParameters. 
              ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
              myPrintParameters.ExportOptions = myExportOptions; // Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY"; // Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "JPG"; // Look to the REST service to see what image formats are supported.
              
              // The UpdateDelay specifys how long (in milliseconds) to wait between asynchronous executions. 
              _PrintTask.UpdateDelay = Convert.ToInt32(TextBox_UpdateDelay.Text);
              
              // Submit the asynchronous geoprocessing task to ArcGIS Server. 
              _PrintTask.SubmitJobAsync(myPrintParameters);
              
              // Enable button for the user to cancel the PrintTask request.
              Button_CancelJobAsync.IsEnabled = true;
            }
            
            private void printTask_JobCompleted(object sender, ESRI.ArcGIS.Client.Printing.PrintJobEventArgs e)
            {
              // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              // Test if we have valid results coming back from ArcGIS Server.
              if (e.PrintResult != null)
              {
                if (e.PrintResult.Url != null)
                {
                  // Open a new internet browser window with the generated image from the PrintTask. 
                  System.Windows.Browser.HtmlPage.Window.Navigate(e.PrintResult.Url, "_blank");
                  
                  // Clear out the JobInfo messages since we have completed the asynchronous geoprocessing task. 
                  TextBlock_JobId.Text = "";
                  TextBlock_JobStatus.Text = "";
                  ListBox_Messages.Items.Clear();
                }
              }
            }
            
            private void Button_CancelJobAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              // This will kill the asynchronous geoprocessing task. Notifications via the PrintTask.StatusUpdated Event
              // will still occur.
            _PrintTask.CancelJobAsync(TextBlock_JobId.Text);
            }
            
            private void printTask_StatusUpdated(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
            {
              // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              // This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
              // can fire multiple times depending on the state of the geoprocessing task executing.
              
              // Clear out any existing JobInfo messages.
              TextBlock_JobId.Text = "";
              TextBlock_JobStatus.Text = "";
              ListBox_Messages.Items.Clear();
              
              // Get the JobInfo information messages.
              ESRI.ArcGIS.Client.Tasks.JobInfo myJobInfo = e.JobInfo;
              string myJobId = myJobInfo.JobId;
              ESRI.ArcGIS.Client.Tasks.esriJobStatus myJobStatus = myJobInfo.JobStatus;
              List&lt;ESRI.ArcGIS.Client.Tasks.GPMessage&gt; myMessages = myJobInfo.Messages;
              
              // Display the JobInfo messages to the user.
              TextBlock_JobId.Text = myJobId;
              TextBlock_JobStatus.Text = myJobStatus.ToString();
              foreach (ESRI.ArcGIS.Client.Tasks.GPMessage myMessage in myMessages)
              {
                ListBox_Messages.Items.Add(myMessage.Description);
              }
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create a Global (aka. Member) variable for the PrintTask object that will be used in other 
            ' parts of the application.
            Private _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
            
            Public Sub New()
              
              InitializeComponent()
              
              ' Provide a valid PrintTask.Url for a "asynchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export%20Web%20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = True
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the PrintTask.StatusUpdated Event.
              AddHandler _PrintTask.StatusUpdated, AddressOf printTask_StatusUpdated
              
              ' Wire up an Event Handler for the PrintTask.JobCompleted Event.
              AddHandler _PrintTask.JobCompleted, AddressOf printTask_JobCompleted
              
            End Sub
            
            Private Sub Button_SubmitJobAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              ' Define the ExportOptions.
              Dim myExportOptions As New ESRI.ArcGIS.Client.Printing.ExportOptions
              myExportOptions.Dpi = 96 '96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = New Size(MyMap.ActualWidth, MyMap.ActualHeight) ' Use the dimensions of the Map
              
              ' Define the PrintParameters. 
              Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
              myPrintParameters.ExportOptions = myExportOptions ' Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY" ' Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "JPG" ' Look to the REST service to see what image formats are supported.
              
              ' The UpdateDelay specifys how long (in milliseconds) to wait between asynchronous executions. 
              _PrintTask.UpdateDelay = CInt(TextBox_UpdateDelay.Text)
              
              ' Submit the asynchronous geoprocessing task to ArcGIS Server. 
              _PrintTask.SubmitJobAsync(myPrintParameters)
              
              ' Enable button for the user to cancel the PrintTask request.
              Button_CancelJobAsync.IsEnabled = True
              
            End Sub
            
            Private Sub printTask_JobCompleted(sender As Object, e As ESRI.ArcGIS.Client.Printing.PrintJobEventArgs)
              
              ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              ' Test if we have valid results coming back from ArcGIS Server.
              If e.PrintResult IsNot Nothing Then
                If e.PrintResult.Url IsNot Nothing Then
                  
                  ' Open a new internet browser window with the generated image from the PrintTask. 
                  System.Windows.Browser.HtmlPage.Window.Navigate(e.PrintResult.Url, "_blank")
                  
                  ' Clear out the JobInfo messages since we have completed the asynchronous geoprocessing task. 
                  TextBlock_JobId.Text = ""
                  TextBlock_JobStatus.Text = ""
                  ListBox_Messages.Items.Clear()
                  
                End If
              End If
              
            End Sub
            
            Private Sub Button_CancelJobAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              ' This will kill the asynchronous geoprocessing task. Notifications via the PrintTask.StatusUpdated Event
              ' will still occur.
              _PrintTask.CancelJobAsync(TextBlock_JobId.Text)
              
            End Sub
            
            Private Sub printTask_StatusUpdated(sender As Object, e As ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs)
              
              ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              ' This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
              ' can fire multiple times depending on the state of the geoprocessing task executing.
              
              ' Clear out any existing JobInfo messages.
              TextBlock_JobId.Text = ""
              TextBlock_JobStatus.Text = ""
              ListBox_Messages.Items.Clear()
              
              ' Get the JobInfo information messages.
              Dim myJobInfo As ESRI.ArcGIS.Client.Tasks.JobInfo = e.JobInfo
              Dim myJobId As String = myJobInfo.JobId
              Dim myJobStatus As ESRI.ArcGIS.Client.Tasks.esriJobStatus = myJobInfo.JobStatus
              Dim myMessages As List(Of ESRI.ArcGIS.Client.Tasks.GPMessage) = myJobInfo.Messages
              
              ' Display the JobInfo messages to the user.
              TextBlock_JobId.Text = myJobId
              TextBlock_JobStatus.Text = myJobStatus.ToString
              For Each myMessage As ESRI.ArcGIS.Client.Tasks.GPMessage In myMessages
                ListBox_Messages.Items.Add(myMessage.Description)
              Next
              
            End Sub
            </code>
            </example>		
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobStatusUpdates(System.String)">
            <summary>
            Cancels the job status updates such that the StatusUpdated and JobCompleted Events stops firing.
            </summary>
            <param name="jobId">The job id.</param>
            <remarks>
            <para>
            Invoking the CancelJobStatusUpdates Method immediately terminates the 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">PrintTask.StatusUpdated</see> and 
            <see cref="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted">PrintTask.JobCompleted</see> Events 
            from firing for a particular 
            <see cref="P:ESRI.ArcGIS.Client.Tasks.JobInfo.JobId">ESRI.ArcGIS.Client.Tasks.JobInfo.JobId</see>. 
            However, the PrintTask job itself has not terminated on the ArcGIS Server. See the following diagram 
            for the visual representation of the 'asynchronous geoprocessing task' flow:
            </para>
            <para>
            <img border="0" alt="Diagram of the 'asynchronous geoprocessing task' flow." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.CancelJobStatusUpdates_2.png"/>
            </para>
            <para>
            A common work flow for calling the CancelJobStatusUpdates Method might be a really long 
            PrintTask job where the user needs to close out of the application before the job completes. If the 
            JobId was stored on disk or saved via some other mechanism, the image could still be retrieved via 
            the <see cref="T:ESRI.ArcGIS.Client.Tasks.Geoprocessor">ESRI.ArcGIS.Client.Tasks.Geoprocessor</see> Class. 
            See the code example in this document for an example of using the Geoprocessor to obtain the image
            generated on ArcGIS Server as a result of an 'asynchronous geoprocessing task' using the PrintTask where
            the CancelJobStatusUpdates was used.
            </para>
            </remarks>
            <example>
            <para>
            <b>How to use:</b>
            </para>
            <para>
            When the application loads, enter a correct Url to an ArcGIS Server PrintTask based on an 'asynchronous 
            geoprocessing task'. Then click the 'SubmitJobAsync|CancelJobStatusUpdates' button (this will start a 
            Print Task, obtain a JobID, and cancel all Job Status Updates from occuring). Then click the 'Get Job 
            via Geoprocessor' to obtain the image started by the PrintTask via the Geoprocessor.
            </para>
            <para>
            The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate
            the functionality.
            </para>
            <para>
            The following screen shot corresponds to the code example in this page.
            </para>
            <para>
            <img border="0" alt="Showing how once a PrintTask.CancelJobStatusUpdates has been issued that the image can be returned via the Geoprocessor Class." src="C:\ArcGIS\dotNET\API SDK\Main\ArcGISSilverlightSDK\LibraryReference\images\Client.Printing.PrintTask.CancelJobStatusUpdates_1.png"/>
            </para>
            <code title="Example XAML1" description="" lang="XAML">
            &lt;Grid x:Name="LayoutRoot" Background="White"&gt;
              &lt;esri:Map Background="White" HorizontalAlignment="Left" Margin="14,368,0,0" 
                        Name="MyMap" VerticalAlignment="Top" WrapAround="True" Height="222" Width="600"
                        Extent="-14130480,2889032,-7273626,6317460"&gt;
                &lt;esri:Map.Layers&gt;
                  &lt;esri:LayerCollection&gt;
                  
                    &lt;!-- Add a layer to the Map Control. --&gt;
                    &lt;esri:ArcGISDynamicMapServiceLayer ID="MyArcGISDynamicMapServiceLayer"
                      Url="http://services.arcgisonline.com/ArcGIS/rest/services/Demographics/USA_1990-2000_Population_Change/MapServer"/&gt;
                    
                  &lt;/esri:LayerCollection&gt;
                &lt;/esri:Map.Layers&gt;
              &lt;/esri:Map&gt;
              
              &lt;!-- Url --&gt;
              &lt;sdk:Label Height="20" HorizontalAlignment="Left" Margin="8,100,0,0" Name="Label_Url" 
                         VerticalAlignment="Top" Width="31" Content="Url:"/&gt;
              &lt;TextBox Height="23" HorizontalAlignment="Left" Margin="8,118,0,0" Name="TextBox_Url" 
                       VerticalAlignment="Top" Width="605" FontSize="10" /&gt;
              
              &lt;!-- Buttons to perform the work. --&gt;
              &lt;Button Content="SubmitJobAsync|CancelJobStatusUpdates" Height="72" HorizontalAlignment="Left" Margin="8,162,0,0" 
                      Name="Button_SubmitJobAsync" VerticalAlignment="Top" Width="253" Click="Button_SubmitJobAsync_Click" IsEnabled="True"/&gt;
              &lt;Button Content="Get Job via Geoprocessor" Height="71" Width="253" HorizontalAlignment="Left" Margin="8,242,0,0" 
                      Name="Button_GeoProcessor" VerticalAlignment="Top" Click="Button_GeoProcessor_Click" IsEnabled="False"/&gt;
              
              &lt;!-- JobInfo --&gt;
              &lt;sdk:Label Height="16" HorizontalAlignment="Left" Margin="13,328,0,0" Name="Label_JobId" VerticalAlignment="Top" 
                         Width="35" Content="JobId:"/&gt;
              &lt;TextBlock Height="16" HorizontalAlignment="Left" Margin="14,346,0,0" Name="TextBlock_JobId" 
                         VerticalAlignment="Top" Width="247" /&gt;
            
              &lt;!-- Informational Messages --&gt;
              &lt;sdk:Label Height="21" HorizontalAlignment="Left" Margin="267,147,0,0" Name="Label_InfoMessage" 
                         VerticalAlignment="Top" Width="169" Content="Informatonal Messages:"/&gt;
              &lt;ListBox Height="200" HorizontalAlignment="Left" Margin="267,162,0,0" Name="ListBox_InfoMessage" 
                       VerticalAlignment="Top" Width="346" /&gt;
              
              &lt;!-- Provide the instructions on how to use the sample code. --&gt;
              &lt;TextBlock Height="91" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="625" 
                 TextWrapping="Wrap" Text="When the application loads, enter a correct Url to an ArcGIS Server PrintTask 
                  based on an 'asynchronous geoprocessing task'. Then click the 'SubmitJobAsync|CancelJobStatusUpdates' 
                  button (this will start a Print Task, obtain a JobID, and cancel all Job Status Updates from occuring). 
                  Then click the 'Get Job via Geoprocessor' to obtain the image started by the PrintTask via the 
                  Geoprocessor." /&gt;
                  
            &lt;/Grid&gt;
            </code>
            <code title="Example CS1" description="" lang="CS">
            // Create Global (aka. Member) variables for the PrintTask and Geoprocessor objects that will be 
            // used in other parts of the application.
            private ESRI.ArcGIS.Client.Printing.PrintTask _PrintTask;
            private ESRI.ArcGIS.Client.Tasks.Geoprocessor _Geoprocessor;
            
            public MainPage()
            {
              InitializeComponent();
              
              // Provide a valid PrintTask.Url for a "asynchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export20Web20Map%20Task";
              
              // Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = new ESRI.ArcGIS.Client.Printing.PrintTask();
              
              // Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = true;
              
              // Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the PrintTask.StatusUpdated Event.
              _PrintTask.StatusUpdated += printTask_StatusUpdated;
              
              // Set the _Geoprocessor variable to a new instance of the Geoprocessor Class.
              _Geoprocessor = new ESRI.ArcGIS.Client.Tasks.Geoprocessor();
              
              // Set the Geoprocessor.Url from what is entered in the TextBox.
              _Geoprocessor.Url = TextBox_Url.Text;
              
              // Wire up an Event Handler for the Geoprocessor.StatusUpdated Event.
              _Geoprocessor.StatusUpdated += geoprocessor_StatusUpdated;
              
              // Wire up an Event Handler for the Geoprocessor.GetResultDataCompleted Event.
              _Geoprocessor.GetResultDataCompleted += geoprocessor_GetResultDataCompleted;
            }
            
            private void Button_SubmitJobAsync_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              // Define the ExportOptions.
              ESRI.ArcGIS.Client.Printing.ExportOptions myExportOptions = new ESRI.ArcGIS.Client.Printing.ExportOptions();
              myExportOptions.Dpi = 96; //96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = new Size(MyMap.ActualWidth, MyMap.ActualHeight); // Use the dimensions of the Map
              
              // Define the PrintParameters. 
              ESRI.ArcGIS.Client.Printing.PrintParameters myPrintParameters = new ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap);
              myPrintParameters.ExportOptions = myExportOptions; // Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY"; // Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "PNG32"; // Look to the REST service to see what image formats are supported.
              
              // Submit the 'PrintTask based asynchronous geoprocessing task' to ArcGIS Server. 
              _PrintTask.SubmitJobAsync(myPrintParameters);
              
              // Enable the Button for the user to retieve the ArcGIS Server exported image/.pdf via the Geoprocessor.
              Button_GeoProcessor.IsEnabled = true;
              
              // Display an informational message.
              ListBox_InfoMessage.Items.Add("The PrintTask to generate the image was started.");
            }
            
            private void printTask_StatusUpdated(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
            {
              // Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              // This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
              // can fire multiple times depending on the state of the geoprocessing task executing.
              
              // Clear out the TextBlock any existing JobInfo messages.
              TextBlock_JobId.Text = "";
              
              // Get the JobInfo information messages.
              ESRI.ArcGIS.Client.Tasks.JobInfo myJobInfo = e.JobInfo;
              string myJobId = myJobInfo.JobId;
              
              // Display the JobInfo messages to the user.
              TextBlock_JobId.Text = myJobId;
              
              // Display an informational message.
              ListBox_InfoMessage.Items.Add("The PrintTask JobId was obtained.");
              
              // As soon as we get our first update on the Job in this Event, call the PrintTask.CancelJobStatusUpdates 
              // which will kill all future PrintTask.StatusUpdated Events (i.e. this Event) from firing. NOTE: the actual
              // PrintTask job is still submitted to the ArcGIS Server geoprocessor and is running/completed.
              _PrintTask.CancelJobStatusUpdates(TextBlock_JobId.Text);
              
              // Display some informational messages.
              ListBox_InfoMessage.Items.Add("All PrintTask messages have now been canceled.");
              ListBox_InfoMessage.Items.Add("And yet the ArcGIS Server PrintTask is still running.");
              ListBox_InfoMessage.Items.Add("Click the 'Get Job via Geoprocessor' to retrive the image.");
            }
            
            private void Button_GeoProcessor_Click(object sender, System.Windows.RoutedEventArgs e)
            {
              // We can no longer use the PrintTask Class to find out information about the "asynchronous geoprocessing task"
              // that was submitted via the PrintTask.SubmitJobAsync() Method because the PrintTask.CancelJobStatusUpdates was 
              // issued. We now need to use the Geoprocessor Class to find out information about the job by supplying the JobId 
              // obtained in the last PrintTask.StatusUpdated Event.
              // A common work flow for this type of situation might be a really long PrintTask job where the user needs to 
              // close out of the application before the job completes. If the JobId was stored on disk or saved via some other
              // mechanism, the image could still be retrieved via the Geoprocessor Class.
              _Geoprocessor.CheckJobStatusAsync(TextBlock_JobId.Text);
            }
            
            private void geoprocessor_StatusUpdated(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
            {
              // This Event fires as a result of the Geoprocessor.CheckJobStatusAsync Method call.
              
              // Get the JobInfo.
              ESRI.ArcGIS.Client.Tasks.JobInfo myJobInfo = e.JobInfo;
              
              // Ensure we have valid results.
              if (myJobInfo != null)
              {
                // Get the JobStatus from the JobInfo.
                ESRI.ArcGIS.Client.Tasks.esriJobStatus myJobStatus = myJobInfo.JobStatus;
                
                // The PrintTask operation that generates the image completed.
                if (myJobStatus == ESRI.ArcGIS.Client.Tasks.esriJobStatus.esriJobSucceeded)
                {
                  // Display an informational message.
                  ListBox_InfoMessage.Items.Add("The image file was found via the Geoprocessor.");
                  
                  // Invoke the Geoprocessor.GetResultDataAsync Method so we can retrieve the image.
                  // The string parameter "Output_File" was obtained from the 'ArcGIS REST Service Directory' 
                  // for the Url of the PrintTask and Geoprocessor services. Look for the 'Parameter' that is 
                  // of 'Direction' esriGPParameterDirectionOutput.
                  _Geoprocessor.GetResultDataAsync(TextBlock_JobId.Text, "Output_File");
                }
              }
            }
            
            private void geoprocessor_GetResultDataCompleted(object sender, ESRI.ArcGIS.Client.Tasks.GPParameterEventArgs e)
            {
              // Get the GPDataFile from the e.Parameter.
              ESRI.ArcGIS.Client.Tasks.GPDataFile myGPDataFile = e.Parameter as ESRI.ArcGIS.Client.Tasks.GPDataFile;
              
              // Make sure we have a valid result.
              if (myGPDataFile != null)
              {
                // Get the Url String.
                string myUrl = myGPDataFile.Url;
                
                // Create a Uri from the Url String.
                Uri myUri = new Uri(myUrl);
                
                // Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank");
                
                // Display an informational message.
                ListBox_InfoMessage.Items.Add("The image file was returned in a web browser.");
              }
            }
            </code>
            <code title="Example VB1" description="" lang="VB.NET">
            ' Create Global (aka. Member) variables for the PrintTask and Geoprocessor objects that will be 
            ' used in other parts of the application.
            Private _PrintTask As ESRI.ArcGIS.Client.Printing.PrintTask
            Private _Geoprocessor As ESRI.ArcGIS.Client.Tasks.Geoprocessor
            
            Public Sub New()
            
              InitializeComponent()
              
              ' Provide a valid PrintTask.Url for a "asynchronous geoprocessing task"
              TextBox_Url.Text = "http://localhost:6080/arcgis/rest/services/Utilities/PrintingTools/GPServer/Export20Web20Map%20Task"
              
              ' Set the _PrintTask variable to a new instance of the PrintTask Class.
              _PrintTask = New ESRI.ArcGIS.Client.Printing.PrintTask()
              
              ' Prevent the internet browser from using a cache for the PrintTask operations.
              _PrintTask.DisableClientCaching = True
              
              ' Set the PrintTask.Url from what is entered in the TextBox.
              _PrintTask.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the PrintTask.StatusUpdated Event.
              AddHandler _PrintTask.StatusUpdated, AddressOf printTask_StatusUpdated
              
              ' Set the _Geoprocessor variable to a new instance of the Geoprocessor Class.
              _Geoprocessor = New ESRI.ArcGIS.Client.Tasks.Geoprocessor
              
              ' Set the Geoprocessor.Url from what is entered in the TextBox.
              _Geoprocessor.Url = TextBox_Url.Text
              
              ' Wire up an Event Handler for the Geoprocessor.StatusUpdated Event.
              AddHandler _Geoprocessor.StatusUpdated, AddressOf geoprocessor_StatusUpdated
              
              ' Wire up an Event Handler for the Geoprocessor.GetResultDataCompleted Event.
              AddHandler _Geoprocessor.GetResultDataCompleted, AddressOf geoprocessor_GetResultDataCompleted
              
            End Sub
            
            Private Sub Button_SubmitJobAsync_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' Define the settings for rendering the image/.pdf on the ArcGIS Server.
              
              ' Define the ExportOptions.
              Dim myExportOptions As New ESRI.ArcGIS.Client.Printing.ExportOptions
              myExportOptions.Dpi = 96 '96 DPI is typical Window OS setting.
              myExportOptions.OutputSize = New Size(MyMap.ActualWidth, MyMap.ActualHeight) ' Use the dimensions of the Map
              
              ' Define the PrintParameters. 
              Dim myPrintParameters As New ESRI.ArcGIS.Client.Printing.PrintParameters(MyMap)
              myPrintParameters.ExportOptions = myExportOptions ' Use the ExportOptions defined earlier.
              myPrintParameters.LayoutTemplate = "MAP_ONLY" ' Look to the REST service to see what layout templates are supported.
              myPrintParameters.Format = "PNG32" ' Look to the REST service to see what image formats are supported.
              
              ' Submit the 'PrintTask based asynchronous geoprocessing task' to ArcGIS Server. 
              _PrintTask.SubmitJobAsync(myPrintParameters)
              
              ' Enable the Button for the user to retieve the ArcGIS Server exported image/.pdf via the Geoprocessor.
              Button_GeoProcessor.IsEnabled = True
              
              ' Display an informational message.
              ListBox_InfoMessage.Items.Add("The PrintTask to generate the image was started.")
              
            End Sub
              
            Private Sub printTask_StatusUpdated(sender As Object, e As ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs)
              
              ' Use only for SubmitJobAsync operations (i.e. asynchronous geoprocessing tasks).
              
              ' This Event fires as a result of the PrintTask.SumbitJobAsync Method being used previously. It 
              ' can fire multiple times depending on the state of the geoprocessing task executing.
              
              ' Clear out the TextBlock any existing JobInfo messages.
              TextBlock_JobId.Text = ""
              
              ' Get the JobInfo information messages.
              Dim myJobInfo As ESRI.ArcGIS.Client.Tasks.JobInfo = e.JobInfo
              Dim myJobId As String = myJobInfo.JobId
              
              ' Display the JobInfo messages to the user.
              TextBlock_JobId.Text = myJobId
              
              ' Display an informational message.
              ListBox_InfoMessage.Items.Add("The PrintTask JobId was obtained.")
              
              ' As soon as we get our first update on the Job in this Event, call the PrintTask.CancelJobStatusUpdates 
              ' which will kill all future PrintTask.StatusUpdated Events (i.e. this Event) from firing. NOTE: the actual
              ' PrintTask job is still submitted to the ArcGIS Server geoprocessor and is running/completed.
              _PrintTask.CancelJobStatusUpdates(TextBlock_JobId.Text)
              
              ' Display some informational messages.
              ListBox_InfoMessage.Items.Add("All PrintTask messages have now been canceled.")
              ListBox_InfoMessage.Items.Add("And yet the ArcGIS Server PrintTask is still running.")
              ListBox_InfoMessage.Items.Add("Click the 'Get Job via Geoprocessor' to retrive the image.")
              
            End Sub
              
            Private Sub Button_GeoProcessor_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
              
              ' We can no longer use the PrintTask Class to find out information about the "asynchronous geoprocessing task"
              ' that was submitted via the PrintTask.SubmitJobAsync() Method because the PrintTask.CancelJobStatusUpdates was 
              ' issued. We now need to use the Geoprocessor Class to find out information about the job by supplying the JobId 
              ' obtained in the last PrintTask.StatusUpdated Event.
              ' A common work flow for this type of situation might be a really long PrintTask job where the user needs to 
              ' close out of the application before the job completes. If the JobId was stored on disk or saved via some other
              ' mechanism, the image could still be retrieved via the Geoprocessor Class.
              _Geoprocessor.CheckJobStatusAsync(TextBlock_JobId.Text)
              
            End Sub
            
            Private Sub geoprocessor_StatusUpdated(sender As Object, e As ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs)
              
              ' This Event fires as a result of the Geoprocessor.CheckJobStatusAsync Method call.
              
              ' Get the JobInfo.
              Dim myJobInfo As ESRI.ArcGIS.Client.Tasks.JobInfo = e.JobInfo
              
              ' Ensure we have valid results.
              If myJobInfo IsNot Nothing Then
                
                ' Get the JobStatus from the JobInfo.
                Dim myJobStatus As ESRI.ArcGIS.Client.Tasks.esriJobStatus = myJobInfo.JobStatus
                
                ' The PrintTask operation that generates the image completed.
                If myJobStatus = ESRI.ArcGIS.Client.Tasks.esriJobStatus.esriJobSucceeded Then
                  
                  ' Display an informational message.
                  ListBox_InfoMessage.Items.Add("The image file was found via the Geoprocessor.")
                  
                  ' Invoke the Geoprocessor.GetResultDataAsync Method so we can retrieve the image.
                  ' The string parameter "Output_File" was obtained from the 'ArcGIS REST Service Directory' 
                  ' for the Url of the PrintTask and Geoprocessor services. Look for the 'Parameter' that is 
                  ' of 'Direction' esriGPParameterDirectionOutput.
                  _Geoprocessor.GetResultDataAsync(TextBlock_JobId.Text, "Output_File")
                  
                End If
                
              End If
              
            End Sub
            
            Private Sub geoprocessor_GetResultDataCompleted(sender As Object, e As ESRI.ArcGIS.Client.Tasks.GPParameterEventArgs)
              
              ' Get the GPDataFile from the e.Parameter.
              Dim myGPDataFile As ESRI.ArcGIS.Client.Tasks.GPDataFile = TryCast(e.Parameter, ESRI.ArcGIS.Client.Tasks.GPDataFile)
              
              ' Make sure we have a valid result.
              If myGPDataFile IsNot Nothing Then
                
                ' Get the Url String.
                Dim myUrl As String = myGPDataFile.Url
                
                ' Create a Uri from the Url String.
                Dim myUri As New Uri(myUrl)
                
                ' Open a new internet browser window with the generated image from the PrintTask.
                System.Windows.Browser.HtmlPage.Window.Navigate(myUri, "_blank")
                
                ' Display an informational message.
                ListBox_InfoMessage.Items.Add("The image file was returned in a web browser.")
                
              End If
              
            End Sub
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.CancelJobAsync(System.String)">
            <summary>
            Cancels the asynchronous GP job before it is completed.
            </summary>
            <param name="jobId">The job id.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.OnExecuteCompleted(ESRI.ArcGIS.Client.Printing.PrintEventArgs)">
            <summary>
            Raises the <see cref="E:ExecuteCompleted"/> event.
            </summary>
            <param name="args">The <see cref="T:ESRI.ArcGIS.Client.Printing.PrintEventArgs"/> 
            instance containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.OnGetServiceInfoCompleted(ESRI.ArcGIS.Client.Printing.ServiceInfoEventArgs)">
            <summary>
            Raises the <see cref="E:GetServiceInfoCompleted"/> event.
            </summary>
            <param name="e">The <see cref="T:System.EventArgs"/> 
            instance containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.OnStatusUpdated(ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs)">
            <summary>
            Raises the <see cref="E:StatusUpdated"/> event.
            </summary>
            <param name="args">The <see cref="T:ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs"/> instance containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.PrintTask.OnSubmitJobCompleted(ESRI.ArcGIS.Client.Printing.PrintJobEventArgs)">
            <summary>
            Raises the <see cref="e:JobCompleted"/> event.
            </summary>
            <param name="args">The <see cref="T:ESRI.ArcGIS.Client.Printing.PrintJobEventArgs"/> instance containing the event data.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.UpdateDelay">
            <summary>
            The time interval in milliseconds between each print job 
            status request sent to an asynchronous print task.
            The default is 1000.
            </summary>
            <value>The update delay.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.Url">
            <summary>
            Gets or sets the URL of the task.
            </summary>
            <value>The URL.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.ProxyURL">
            <summary>
            Gets or sets the URL to proxy the request through.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.DisableClientCaching">
            <summary>
            If true, adds a timestamp parameter ("_ts") to the request to prevent it from 
            being loaded from the browser's cache.
            </summary>
            <value>
            	<c>true</c> to disable client caching otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.Token">
            <summary>
            Token for accessing a secure ArcGIS task.
            </summary>
            <value>The token.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.PrintTask.IsBusy">
             <summary>
            Gets a value that indicates whether a Web request is in progress.
             </summary>
             <value><c>true</c> to indicate a Web request is in progress; otherwise, <c>false</c>.</value>
        </member>
        <member name="E:ESRI.ArcGIS.Client.Printing.PrintTask.ExecuteCompleted">
            <summary>
            Occurs when the print is completed.
            This event is raised when Print method is called.
            </summary>
        </member>
        <member name="E:ESRI.ArcGIS.Client.Printing.PrintTask.GetServiceInfoCompleted">
            <summary>
            Occurs when get service information is completed.
            This event is raised when GetServiceInfo method is called.
            </summary>
        </member>
        <member name="E:ESRI.ArcGIS.Client.Printing.PrintTask.StatusUpdated">
            <summary>
            Occurs when the print status is updated.
            This event is raised when  <see cref="M:ESRI.ArcGIS.Client.Printing.PrintTask.SubmitJobAsync(ESRI.ArcGIS.Client.Printing.PrintParameters,System.Object)"/> is called.
            </summary>
        </member>
        <member name="E:ESRI.ArcGIS.Client.Printing.PrintTask.JobCompleted">
            <summary>
            Occurs when print job is completed. 
            This event is raised when SubmitPrintJob method is called.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.Properties.Resources">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Generic_GeometryTypeNotSupported">
            <summary>
              Looks up a localized string similar to Geometry type is not supported..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Generic_MixGeometryTypeNotSupported">
            <summary>
              Looks up a localized string similar to Mix geometry types are not supported..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Generic_RequiredParameterIsNullOrEmpty">
            <summary>
              Looks up a localized string similar to Required parameter is null or empty..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Generic_UrlNotSet">
            <summary>
              Looks up a localized string similar to &apos;Url&apos; is not set..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.JSON_InvalidOrNotSupportedJson">
            <summary>
              Looks up a localized string similar to JSON string is invalid or not supported..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.JsonValue_InvalidCast">
            <summary>
              Looks up a localized string similar to Cannot cast &apos;JsonValue.&apos;.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.JsonValue_OperationNotSupported">
            <summary>
              Looks up a localized string similar to Operation not supported for this &apos;JsonValue.&apos;.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.JsonWriter_EndNoMatchingStart">
            <summary>
              Looks up a localized string similar to &apos;{0}&apos; called with no matching &apos;{1}&apos;..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.JsonWriter_PropertyCalledOutsideObject">
            <summary>
              Looks up a localized string similar to &apos;{0}&apos; called outside of an object..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.NativeDisplay_JsonSerializationOfRendererNotSupported">
            <summary>
              Looks up a localized string similar to Renderer is not serializable to JSON.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.NativeDisplay_JsonSerializationOfSymbolNotSupported">
            <summary>
              Looks up a localized string similar to Graphic Symbol is not serializable to JSON.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Printing_LayerNotSupported">
            <summary>
              Looks up a localized string similar to Layer of type {0} is not supported for printing..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.Printing_PrintJobFailure">
            <summary>
              Looks up a localized string similar to Print job failed to continue. Please check print job info for more details..
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.WebRequest_ConcurrencyNotSupported">
            <summary>
              Looks up a localized string similar to Request does not support concurrent I/O operations.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Properties.Resources.WebRequest_RelativeUrlNotSupported">
            <summary>
              Looks up a localized string similar to Relative URLs are not allowed.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.ScaleBarOptions">
            <summary>
            Defines settings specific to ScaleBar
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Printing.ScaleBarOptions"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnit">
            <summary>
            Gets or sets the metric unit.
            esriMeters, esriKilometers
            </summary>
            <value>The metric unit.</value>		
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnit">
            <summary>
            Gets or sets the non metric unit.
            </summary>
            <value>The non metric unit.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricLabel">
            <summary>
            Gets or sets the metric unit label.
            </summary>
            <value>The metric unit label.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricLabel">
            <summary>
            Gets or sets the non metric label.
            </summary>
            <value>The non metric label.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnits">
            <summary>
            metric unit
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnits.Meters">
            <summary>Meters.</summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.MetricUnits.Kilometers">
            <summary>Kilometers.</summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits">
            <summary>
            esri non-metric units
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.Feet">
            <summary>
            Feet
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.Yards">
            <summary>
            Yards
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.Miles">
            <summary>
            Miles
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Printing.ScaleBarOptions.NonMetricUnits.NauticalMiles">
            <summary>
            Nautical Miles
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper">
            <summary>
            Helper class that builds a valid json property based on key-value parameters.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Collections.Generic.IEnumerable{System.Double[]})">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="values">The values.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Double)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">The value.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.String)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">The value.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Int32)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">The value.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Boolean)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">if set to <c>true</c> [value].</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="values">The values.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="values">The values.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Collections.Generic.IEnumerable{System.Json.JsonValue})">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="values">The values.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Json.JsonObject)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">The value.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonHelper.CreateJsonProperty(System.String,System.Json.JsonValue)">
            <summary>
            Creates the json property.
            </summary>
            <param name="name">The name.</param>
            <param name="value">The value.</param>
            <returns></returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter">
            <summary>
            General purpose class for writing out JSON.  Can optionally format the output
            in a "pretty" format with carriage returns, white space, and indenting for ease of reading.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.#ctor(System.IO.TextWriter,System.Int32)">
            <summary>
            Initializes a new instance of the JsonWriter class that renders 
            "pretty" JSON.
            </summary>
            <param name="writer">The TextWriter instance to use to write out JSON.</param>
            <param name="indent">The number of spaces to use for indenting.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.#ctor(System.IO.TextWriter)">
            <summary>
            Initializes a new instance of the JsonWriter class that writes to a 
            single compact line.
            </summary>
            <param name="writer">The TextWriter instance to use to write out 
            JSON.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartObject">
            <summary>
            Writes a left brace to start a new object.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartObjectIndented">
            <summary>
            Writes a left brace to start a new object.
            If Pretty=true the brace will written on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartAppendObjectIndented">
            <summary>
            Writes a comma followed by a left brace to start a new object.
            If Pretty=true the brace will written on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.EndObject">
            <summary>
            Writes a right brace to end the current object.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.EndObjectIndented">
            <summary>
            Writes the closing right brace to the current object.
            If Pretty=true the brace will written on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartArray">
            <summary>
            Writes a left bracket to start a new array.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartArrayIndented">
            <summary>
            Writes a left bracket to start a new array.
            If Pretty=true the bracket will written on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.EndArray">
            <summary>
            Writes a right bracket to end the current array.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.EndArrayIndented">
            <summary>
            Writes the closing right bracket to the current array.
            If Pretty=true the bracket will written on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartProperty(System.String)">
            <summary>
            Writes the property name followed by a colon.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartPropertyIndented(System.String)">
            <summary>
            Writes the property name followed by a colon.
            If Pretty=true the property will be started on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartAppendProperty(System.String)">
            <summary>
            Writes a comma followed by the property name followed by a colon.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.StartAppendPropertyIndented(System.String)">
            <summary>
            Writes a comma followed by the property name followed by a colon.
            If Pretty=true the property will be started on a new line.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.BuildDynamicLayerEntry(ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter,System.Int32,ESRI.ArcGIS.Client.LayerSource,ESRI.ArcGIS.Client.LayerDrawingOptions,System.String,ESRI.ArcGIS.Client.Tasks.TimeOption,System.Boolean)">
            <summary>
            Writes a dynamic layer to a JSON writer.
            </summary>
            <param name="jw">The JSON Writer instance to write to (required).</param>
            <param name="layerID">The ID of the layer (required).</param>
            <param name="source">The layer source (required).</param>
            <param name="Option">The Drawing Options (optional).</param>
            <param name="definitionExpression">The definition expression (optional).</param>
            <param name="layerTimeOption">The layer time option.</param>
            <param name="insideLayerDefinition">if set to <c>true</c> [inside layer definition].</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.Writer">
            <summary>
            The TextWriter instance used for writing out JSON.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.Utils.Json.JsonWriter.Pretty">
            <summary>
            If true, line returns and indenting are added when writing out JSON for readability.
            If false, the JSON is written out in a single contiguous line.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.Log">
            <summary>
            Internal error logging and handling
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Printing.WebMapSerializers.IWebMapSerializable">
            <summary>
            This interface serializes/deserializes layer to/from webmap JsonObject.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.IWebMapSerializable.WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the name of the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.IWebMapSerializable.ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.IWebMapSerializable.FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.IWebMapSerializable.SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISDynamicSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISDynamicSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISDynamicSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISDynamicSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISDynamicSerializer.Scale">
            <summary>
            Gets or sets the scale layer needs to be drawn.
            </summary>
            <value>The scale.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISTiledSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISTiledSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISTiledSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.ArcGISTiledSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.BingMapsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.BingMapsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.BingMapsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.BingMapsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.FeatureServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="l">The l.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.FeatureServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.FeatureServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.FeatureServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GPResultImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GPResultImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GPResultImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GPResultImageSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GraphicsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GraphicsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GraphicsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.GraphicsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.KmlSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.KmlSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.KmlSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.KmlSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.OpenStreetMapSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.OpenStreetMapSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.OpenStreetMapSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.OpenStreetMapSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmsServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmsServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmsServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmsServiceSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmtsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#WebMapTypeName(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Gets the web map type.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
            <value>The name of the web map type.</value>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmtsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#ToWebMapLayer(ESRI.ArcGIS.Client.Layer)">
            <summary>
            Serializes layer to webmap JsonObject.
            </summary>
            <param name="layer">The layer.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmtsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#FromWebMapLayer(System.Json.JsonObject)">
            <summary>
            Deserializes webmap JsonObject to set layer properties.
            </summary>
            <param name="jsonObject">The json object.</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Printing.WebMapSerializers.Layers.WmtsSerializer.ESRI#ArcGIS#Client#Printing#WebMapSerializers#IWebMapSerializable#SupportedLayerType">
            <summary>
            Gets the type of the supported layer.
            </summary>
            <value>The type of the supported layer.</value>
        </member>
    </members>
</doc>
